FaultLine

Inspiration

Every year, tech companies burn billions of dollars and thousands of engineering hours building features that users politely asked for, but never actually adopt. We realized that *"customer validation" is deeply flawed. In discovery interviews, customers exhibit *politeness bias (praising ideas to be nice) and interviewers fall into leading question traps.

We asked ourselves: What if we could build a system that acts like a lie detector for product discovery? We wanted to build FaultLine—a Risk Decision System that intercepts false signals in customer interviews and calculates the exact financial liability of building a doomed feature before a single line of code is written.

What it does

FaultLine is an AI-driven feature validation auditor. Teams upload their customer interview transcripts, and FaultLine's engine processes the text to identify critical quality triggers:

• Strategic Contradictions: When a user claims a problem is critical but later reveals they rely on a free, low-effort workaround.
• Politeness Bias: Vague, non-committal approval (e.g., "That sounds neat!").
• Leading Prompter Traps: When the interviewer pushes the user toward agreement.
• Behavioral Friction Gaps: A stated desire to use a feature without the budget, authority, or urgency to actually adopt it.

The platform then aggregates these triggers into a Feature Fragility Score (FFS) and mathematically models the expected capital loss, giving executives a clear "Commit, Pivot, or Halt" recommendation.

How we built it

We built FaultLine to feel like a high-stakes, mission-critical terminal.

• Frontend: We used React, Vite, and Tailwind CSS to construct a heavily customized, glassmorphic dashboard that adapts flawlessly between a stark dark mode and a crisp light mode.
• Backend & Infrastructure: Node.js and Express handle the API routing, backed by Firebase Data Connect for relational, typed queries and Firebase Auth for secure access.
• AI Engine: We utilized the Google Gemini API to run multi-layered semantic analysis on the transcripts. Rather than asking the LLM for a simple summary, we architected a structured extraction pipeline that isolates quotes and maps them to our strict psychological risk profiles.
• Analytics: We integrated Pendo (and their Novus AI agent) to track user workflows and adoption metrics.

The Math: Calibrating Risk

To convert our raw AI heuristics into actionable financial metrics, we implemented Platt Scaling. We map the raw Feature Fragility Score ($FFS$) against historically validated failure outcomes in our database to calculate the true Probability of Failure ($P_{\text{fail}}$):

$$ P_{\text{fail}} = \frac{1}{1 + e^{A \cdot FFS + B}} $$

Where $A$ and $B$ are scaling coefficients continuously updated by historical feature performance data. We then calculate the Loss Liability by multiplying the allocated engineering budget by this probability:

$$ \text{Expected Loss} = \text{Budget} \times P_{\text{fail}} $$

Challenges we ran into

Our biggest hurdle was prompt engineering and tuning the Gemini API to reliably differentiate between genuine validation and politeness bias. An AI's natural inclination is to read "Yeah, that sounds like a great idea" as a positive signal. We had to heavily constrain the model to demand proof of budget, urgency, or past behavior before accepting a statement as true validation.

Additionally, crafting the complex, animated UI—particularly the interactive transcript sandbox that highlights specific psychological traps in real-time—required extensive state management and precision Tailwind styling.

What we learned

We learned that qualitative data (like user interviews) can be rigorously quantified if you apply the right frameworks. We also learned how powerful Firebase Data Connect is for seamlessly blending relational SQL-like architectures into a fast-moving, serverless Firebase environment.

Here is a revised What's next for FaultLine section that focuses on new, ambitious future features rather than the Novus integration!

*

What's next for FaultLine

Now that our core AI engine and analytics integrations are fully operational, we are looking to expand FaultLine from a static analysis tool into a proactive, real-time platform:

• Live Discovery Copilot: We plan to integrate FaultLine directly into Zoom, Google Meet, and Teams. Instead of analyzing transcripts post-mortem, FaultLine will monitor discovery calls in real-time. If an interviewer asks a leading question (e.g., "Don't you think this feature would be helpful?"), a live heads-up display will warn them to pivot to an open-ended question before the validation data is corrupted.
• Dynamic Portfolio Rebalancing: Currently, FaultLine calculates risk on a per-feature basis. Next, we are building a macro-level portfolio manager. As new interview data flows in, the system will automatically recommend how to rebalance engineering sprint hours across dozens of features to continuously minimize total portfolio risk exposure.
• Vocal Sentiment & Hesitation Analysis: We want to move beyond pure text semantics and analyze audio directly. By parsing the tone, cadence, and hesitation in a customer's voice, we can add a new dimension to the Feature Fragility Score, catching instances where a user says "yes" but their vocal micro-expressions indicate doubt or a lack of conviction.

Built With

• express.js
• firebase
• gemini
• github
• node.js
• novus
• pendo
• railway
• react
• tailwind
• typescript
• vite