resolutionflow/docs/plans/KB-Accelerator-Design-Document.md

RESOLUTIONFLOW — KB Accelerator

Feature Design Document

Transform static KB articles into interactive troubleshooting and procedural flows with AI-powered document analysis.

Field	Value
Document	KB Accelerator — Feature Design & Architecture
Version	1.0 — Draft
Date	March 2026
Author	ResolutionFlow LLC
Status	Design Phase

---

Table of Contents

1. Executive Summary
2. Problem Statement & Market Opportunity
3. Feature Overview
4. System Architecture
5. AI Processing Pipeline
6. Data Model
7. API Design
8. Frontend Design
9. Supported Input Formats
10. Conversion Intelligence
11. Pricing & Tier Integration
12. Build Phases & Roadmap
13. Risk Analysis
14. Success Metrics

---

1. Executive Summary

KB Accelerator is a new feature for ResolutionFlow that allows MSP teams to upload their existing knowledge base articles and automatically convert them into interactive troubleshooting flows and procedural flows. This solves the cold-start adoption problem, transforms passive documentation into active troubleshooting tools, and delivers immediate value from day one.

Core Value Proposition

MSPs have years of institutional knowledge trapped in static Word docs, PDFs, and wiki articles that nobody reads mid-ticket. KB Accelerator transforms that content into the interactive, branching flows that ResolutionFlow is built around — turning dead documentation into living troubleshooting intelligence.

Key Capabilities

• Upload KB articles in multiple formats (DOCX, PDF, HTML, Markdown, plain text, copy-paste)
• AI-powered analysis that detects sequential steps, decision points, prerequisites, and resolution outcomes
• Automatic mapping to ResolutionFlow's existing tree schema (troubleshooting flows) and procedural schema (procedure flows)
• Intelligent detection of implicit branching logic buried in prose documentation
• Draft flow output that lands directly in the flow editor for human review and refinement
• Confidence scoring on each generated node so users know where AI interpretation needs attention
• Batch import capability for migrating entire KB libraries

Strategic Impact

Impact Area	Description
Adoption	Eliminates cold-start problem. New users get a library of draft flows on day one instead of building from scratch.
Retention	Users who import existing KB articles are investing their institutional knowledge into the platform, increasing switching costs.
Revenue	Pro/Team-gated feature that directly justifies subscription pricing. AI processing costs are per-conversion, aligning expense with usage.
Differentiation	No competing MSP documentation tool offers AI-powered conversion from static docs to interactive decision trees.
Thesis Validation	Proves the core ResolutionFlow thesis: documentation and troubleshooting should be the same activity.

---

2. Problem Statement & Market Opportunity

2.1 The KB Problem in MSPs

Every MSP has knowledge base articles. They live in ConnectWise, IT Glue, Hudu, SharePoint, Confluence, or simply as Word documents on a shared drive. These articles represent years of accumulated troubleshooting experience and process documentation. The problem is that this content is fundamentally passive. It exists as prose that a technician has to read, interpret, and mentally convert into action steps while simultaneously working a live ticket.

The result is predictable: technicians don't read the KB articles. They ask a senior engineer instead, or they fumble through the issue on their own. The documentation exists but delivers no value because the format doesn't match the workflow.

2.2 The Cold-Start Problem

ResolutionFlow solves the format problem by making documentation interactive. But it introduces a new problem: a new ResolutionFlow customer has zero flows. Building troubleshooting trees from scratch is time-consuming. The customer has to invest significant effort before they see value, and most MSPs don't have that patience.

The Gap

MSPs have the knowledge (in KB articles). ResolutionFlow has the format (interactive flows). KB Accelerator bridges the gap by converting one into the other automatically.

2.3 Competitive Landscape

No MSP-focused tool currently offers AI-powered conversion from static documentation to interactive troubleshooting workflows. IT Glue and Hudu offer structured documentation but no interactive execution. ConnectWise's KB is search-based and static. This is a genuine whitespace opportunity.

---

3. Feature Overview

3.1 User Journey

1. User navigates to KB Accelerator from the ResolutionFlow dashboard (dedicated tab or sidebar action).
2. User uploads a file (DOCX, PDF, HTML, MD, TXT) or pastes raw text content directly.
3. System analyzes the document structure and displays a preview of detected elements: title, problem statement, steps, decision points, prerequisites, and resolution outcomes.
4. User selects target flow type: Troubleshooting Flow (branching decision tree) or Procedure Flow (linear steps with optional intake form).
5. AI processing pipeline generates a draft flow mapped to ResolutionFlow's schema.
6. User reviews the draft in a side-by-side view: original document on the left, generated flow preview on the right.
7. User can accept, edit, or regenerate individual nodes before finalizing.
8. Finalized flow is saved and appears in the user's flow library, ready for use or further editing in the standard flow editor.

3.2 Two Conversion Modes

Troubleshooting Flow Conversion

Best for: diagnostic articles, if/then troubleshooting guides, articles with multiple resolution paths.

• AI identifies the root question or symptom being diagnosed
• Decision nodes are created at each branching point ("if X, try Y; otherwise try Z")
• Resolution nodes capture final outcomes and fix instructions
• The branching tree maps to the existing node/option schema in the trees table

Procedure Flow Conversion

Best for: step-by-step guides, setup procedures, onboarding checklists, runbooks.

• AI extracts sequential steps in order
• Variable placeholders are detected (server names, IPs, usernames) and mapped to [VAR:name] tokens
• An intake form schema is auto-generated from detected variables
• Steps are enriched with detected warnings, time estimates, and verification checks
• Output uses the procedural tree_type with the intake_form JSONB schema from migration 035

---

4. System Architecture

4.1 High-Level Architecture

KB Accelerator integrates into the existing ResolutionFlow stack without introducing new infrastructure. It leverages the FastAPI backend for orchestration, the existing AI service (same infrastructure as the assistant chat) for document analysis, and outputs directly into the existing tree/node schema.

Processing Pipeline Overview

1. UPLOAD        →  2. EXTRACT       →  3. ANALYZE        →  4. GENERATE      →  5. REVIEW
File upload or      Text extraction     AI analysis of       Map to tree/        Side-by-side
text paste via      from DOCX/PDF/      structure, steps,    node schema or      review, edit,
API endpoint        HTML/MD/TXT         decision points      procedure schema    and finalize

4.2 Component Responsibilities

Component	Responsibility	Integration Point
Upload Service	File validation, format detection, size limits, virus scanning hook	FastAPI endpoint, S3/local temp storage
Extraction Service	Convert uploaded files to normalized plain text with structural metadata	python-docx, PyMuPDF, BeautifulSoup, markdown-it
AI Analysis Service	Prompt engineering pipeline that identifies document structure and converts to flow schema	Anthropic API (Claude), existing AI service infrastructure
Flow Generator	Maps AI analysis output to tree/node database records with proper relationships	SQLAlchemy models, existing tree/node CRUD services
Review UI	Side-by-side document vs. flow preview with per-node editing	React frontend, existing flow editor components
Batch Processor	Queue-based processing for multi-article imports	Celery/Redis or async FastAPI background tasks

---

5. AI Processing Pipeline

The AI pipeline is the core intelligence of KB Accelerator. It operates in two phases: structural analysis (understanding the document) and flow generation (converting that understanding into a ResolutionFlow-compatible schema). This two-phase approach allows for human review between analysis and generation.

5.1 Phase 1: Document Analysis

The first AI call analyzes the extracted text and returns a structured JSON document describing what was found. The prompt is carefully engineered to identify MSP-specific patterns.

Analysis Prompt Strategy

• System prompt establishes the AI as an MSP documentation specialist that understands IT troubleshooting workflows
• The extracted text is provided with any structural metadata (headings, lists, numbered steps) preserved
• AI is instructed to return a strict JSON schema identifying: document type, title, problem statement, prerequisites, sequential steps, decision points, resolution outcomes, and detected variables

Detection Targets

Element	What AI Looks For	Example in KB Article
Document Type	Whether the article is diagnostic (troubleshooting) or procedural (step-by-step)	"Troubleshooting Outlook connectivity" vs "Setting up a new domain controller"
Problem Statement	The root issue or task being addressed	"Users report that Outlook keeps disconnecting from Exchange"
Prerequisites	Things that must be true before starting	"Ensure you have Domain Admin credentials and the server is on the network"
Sequential Steps	Ordered instructions that must happen in sequence	"Step 1: Open Server Manager. Step 2: Add Roles and Features..."
Decision Points	Conditional logic, if/then/else branches	"If the user is on Windows 10, check the registry. On Windows 11, go to Settings..."
Variables	Instance-specific values that change per execution	Server names, IP addresses, usernames, license types, domain names
Warnings/Cautions	Risk indicators or critical notes	"WARNING: This will restart the DNS service and cause brief connectivity loss"
Resolution Outcomes	End states that indicate the problem is solved	"Outlook should now maintain a persistent connection to Exchange"
Verification Steps	How to confirm a step or procedure worked	"Run nslookup to verify DNS resolution is working correctly"

5.2 Phase 2: Flow Generation

The second AI call takes the structured analysis from Phase 1 and generates the actual flow structure, mapped directly to ResolutionFlow's schema. The output format differs based on the target flow type.

Troubleshooting Flow Output

• Root node with the problem statement as the question text
• Decision nodes with options array matching the existing node schema (question, options with label and next_node_id)
• Resolution nodes at leaf positions with solution text and tags from the six-dimension tagging system
• Each node includes a confidence_score (0.0–1.0) indicating how certain the AI is about the mapping

Procedure Flow Output

• Ordered steps array with rich metadata (type, content, warnings, time estimates, verification checks)
• Auto-generated intake_form schema from detected variables, with field types inferred (text for names, ip_address for IPs, select for known enumerations)
• [VAR:name] tokens injected into step content wherever variables were detected
• Section headers generated from logical groupings in the source document

5.3 Confidence Scoring

Every generated node includes a confidence score that communicates how certain the AI is about its interpretation. This is critical for the review step — it tells the user exactly where to focus their attention.

Score Range	Label	UI Indicator	Meaning
0.9 – 1.0	High Confidence	Green left accent	Direct mapping from explicit steps or clear logic in the source
0.7 – 0.89	Medium Confidence	Amber left accent	Reasonable inference, but some ambiguity in the source material
0.5 – 0.69	Low Confidence	Red left accent	Significant interpretation required; user should carefully review
< 0.5	Needs Review	Red left accent + flag icon	AI made a best guess but recommends manual editing

Design Note: Left Accent Border Pattern

The confidence indicators use the left accent border pattern established in the ResolutionFlow design system. This provides visual consistency with step status indicators and documentation callouts already in the UI.

---

6. Data Model

KB Accelerator introduces two new database tables and extends the existing tree model. All new tables follow the existing migration pattern and use the same base model infrastructure.

6.1 New Table: kb_imports

Column	Type	Nullable	Description
id	UUID	No	Primary key (gen_random_uuid)
organization_id	UUID FK	No	Foreign key to organizations table
created_by	UUID FK	No	Foreign key to users table (who initiated the import)
source_filename	VARCHAR(500)	Yes	Original filename if file upload (null for text paste)
source_format	VARCHAR(20)	No	Enum: docx, pdf, html, md, txt, paste
source_text	TEXT	No	Extracted plain text content from the source document
source_metadata	JSONB	Yes	Structural metadata from extraction (headings, lists, etc.)
analysis_result	JSONB	Yes	Phase 1 AI analysis output (detected elements)
target_type	VARCHAR(20)	No	Enum: troubleshooting, procedural
generated_flow	JSONB	Yes	Phase 2 AI generation output (flow schema before commit)
tree_id	UUID FK	Yes	Foreign key to trees table (set after user finalizes)
status	VARCHAR(20)	No	Enum: uploaded, extracting, analyzing, reviewed, generating, completed, failed
confidence_avg	FLOAT	Yes	Average confidence score across all generated nodes
error_message	TEXT	Yes	Error details if status = failed
processing_time_ms	INTEGER	Yes	Total processing time in milliseconds
created_at	TIMESTAMPTZ	No	Auto-set on creation
updated_at	TIMESTAMPTZ	No	Auto-updated on modification

6.2 New Table: kb_import_nodes

Stores individual generated nodes/steps before the user commits them to the actual tree. This allows per-node editing during the review phase without touching the live flow data.

Column	Type	Nullable	Description
id	UUID	No	Primary key
kb_import_id	UUID FK	No	Foreign key to kb_imports
node_order	INTEGER	No	Position in the generated flow (0-indexed)
node_type	VARCHAR(20)	No	Enum: question, resolution, step, section_header, warning
content	JSONB	No	Node content (question text, step text, options, etc.)
source_excerpt	TEXT	Yes	The specific text from the source document that this node was derived from
confidence_score	FLOAT	No	AI confidence in this node's accuracy (0.0–1.0)
user_edited	BOOLEAN	No	Whether the user manually modified this node during review
user_approved	BOOLEAN	No	Whether the user explicitly approved this node

6.3 Tree Model Extension

The existing trees table gets one new nullable column to link back to the import that created it. This enables analytics and provenance tracking.

New column: kb_import_id (UUID FK, nullable) — references kb_imports.id. Null for manually-created trees.

---

7. API Design

All KB Accelerator endpoints live under the /api/v1/kb-accelerator prefix and follow existing authentication, organization scoping, and error handling patterns.

7.1 Endpoints

Method	Endpoint	Description
POST	/api/v1/kb-accelerator/upload	Upload a file or submit pasted text. Returns kb_import_id and starts extraction.
GET	/api/v1/kb-accelerator/{id}	Get import status, analysis results, and generated flow data.
GET	/api/v1/kb-accelerator	List all imports for the current organization with pagination and status filter.
POST	/api/v1/kb-accelerator/{id}/analyze	Trigger Phase 1 AI analysis on extracted text. Async — poll status via GET.
POST	/api/v1/kb-accelerator/{id}/generate	Trigger Phase 2 flow generation from analysis results. Requires target_type.
PATCH	/api/v1/kb-accelerator/{id}/nodes/{node_id}	Edit a specific generated node during review (content, approve, reject).
POST	/api/v1/kb-accelerator/{id}/commit	Finalize the import: create actual tree and node records from generated data.
DELETE	/api/v1/kb-accelerator/{id}	Cancel and clean up an in-progress or abandoned import.
POST	/api/v1/kb-accelerator/batch	Submit multiple files for batch processing. Returns array of kb_import_ids.

7.2 Upload Endpoint Detail

POST /api/v1/kb-accelerator/upload

Accepts multipart/form-data for file uploads or application/json for text paste. Validates file size (max 10MB), format, and performs basic content extraction before returning.

Request Body (File Upload)

• file: UploadFile (required) — the KB article file
• target_type: string (optional) — "troubleshooting" or "procedural" (can be set later)

Request Body (Text Paste)

• content: string (required) — raw text content
• title: string (optional) — suggested title for the import
• target_type: string (optional) — "troubleshooting" or "procedural"

Response (201 Created)

• id: UUID — the new kb_import record ID
• status: "uploaded" or "extracting" (extraction may start immediately)
• source_format: detected format of the uploaded content

---

8. Frontend Design

8.1 Entry Points

KB Accelerator is accessible from two locations in the existing UI to maximize discoverability:

• Dashboard action button: a prominent "Import KB Article" button in the flow library header, next to "Create New Flow"
• Sidebar navigation: dedicated "KB Accelerator" item in the main navigation with a sparkle/lightning icon to communicate AI-powered functionality

8.2 Upload Screen

Clean, focused upload interface with two input modes:

• Drag-and-drop zone for file uploads with format badges showing supported types (DOCX, PDF, HTML, MD, TXT)
• Text paste tab with a full-width textarea and title field for direct content entry
• Target type selector (Troubleshooting Flow / Procedure Flow) with visual cards showing the difference
• "Let AI decide" option for target type that uses the analysis phase to recommend the best fit

8.3 Analysis Preview Screen

After Phase 1 analysis completes, the user sees a breakdown of what the AI detected:

• Document title and detected type with AI recommendation badge
• Detected elements displayed as color-coded cards: steps (blue), decision points (amber), warnings (red), variables (green), resolutions (emerald)
• Source text excerpts linked to each detected element so the user can see exactly what triggered the detection
• "Proceed to Generation" and "Re-analyze" action buttons

8.4 Review Screen (Core Experience)

The review screen is the most important UI in KB Accelerator. It's where the user validates AI output and builds trust in the system.

Layout: Two-Panel Side-by-Side

• Left panel: Original document text with detected elements highlighted inline (color-matched to the generated nodes)
• Right panel: Generated flow preview showing the tree structure (for troubleshooting) or step list (for procedures)
• Clicking a node in the right panel highlights its source excerpt in the left panel, and vice versa
• Each node shows its confidence score via the left accent border pattern (green/amber/red)

Per-Node Actions

• Approve (checkmark): Marks the node as reviewed and accepted
• Edit (pencil): Opens inline editing for the node's content, question text, options, etc.
• Regenerate (refresh): Re-runs AI generation for just this node with optional user guidance
• Delete (trash): Removes the node from the generated flow
• Add Node (plus): Insert a manual node between existing ones

Bulk Actions

• "Approve All High Confidence" — one-click approval for all nodes scoring 0.9+
• "Commit to Library" — finalizes the flow and creates the actual tree record

UI Principle

The review screen should feel like a code review, not a form. The user is reviewing AI-generated work with the power to accept, modify, or reject each piece. The side-by-side layout with source attribution builds trust by showing the AI's reasoning.

---

9. Supported Input Formats

Format	Library	Structure Preserved	Notes
DOCX	python-docx	Headings, lists, tables, bold/italic emphasis	Most common format for MSP KB articles in SharePoint and shared drives
PDF	PyMuPDF (fitz)	Text extraction with layout awareness, headings via font size	Second most common; handles scanned docs with OCR fallback via Tesseract
HTML	BeautifulSoup	Full semantic structure (h1-h6, ul/ol, tables, code blocks)	Covers Confluence, IT Glue, and web-based KB exports
Markdown	markdown-it	Headings, lists, code blocks, emphasis, links	Common in developer-oriented documentation and GitHub repos
Plain Text	Built-in	Line breaks and indentation only; AI infers structure	Lowest fidelity but important for copy-paste and email-sourced docs
Paste	Built-in	None — AI infers all structure from content	Zero-friction entry point for quick conversions

Extraction Quality Hierarchy

DOCX and HTML provide the richest structural metadata, giving the AI the most to work with. PDF extraction is good but lossy (formatting information is approximate). Plain text and paste require the AI to infer all structure from content alone, which reduces confidence scores but still produces usable output for well-written articles.

---

10. Conversion Intelligence

This section details the specific AI patterns and heuristics used to convert different types of KB content into flows. This is where KB Accelerator's real value lives — the ability to interpret messy, inconsistent MSP documentation and produce structured, actionable flows.

10.1 Detecting Implicit Branch Logic

The hardest challenge is identifying decision points that aren't explicitly written as if/then statements. MSP KB articles often bury branching logic in prose.

Pattern Examples

KB Article Text	AI Interpretation
"For Windows 10 machines, navigate to Settings > Update. For Windows 11, go to Settings > Windows Update."	Decision node: "What Windows version?" with two branches leading to different step sequences
"If the issue persists after restarting the service, escalate to Tier 2."	Decision node after the restart step: "Did the restart resolve the issue?" with Yes (resolution) and No (escalation) paths
"Note: Domain-joined computers use Group Policy. Workgroup computers need manual configuration."	Decision node: "Is the computer domain-joined?" with two parallel procedure paths
"Try clearing the DNS cache first. If that doesn't work, check the hosts file."	Sequential diagnostic flow: DNS cache clear > verification > hosts file check, with early exit if first step resolves

10.2 Variable Detection

For procedure flow conversion, the AI identifies values that would change between executions and maps them to [VAR:name] tokens with appropriate intake form field types.

Detected Pattern	Variable Name	Form Field Type	Example Value
IP addresses (192.168.x.x)	[VAR:ip_address]	ip_address	192.168.1.10
Server/computer names	[VAR:server_name]	text	DC01
Domain names	[VAR:domain_name]	text	contoso.local
Usernames/email	[VAR:username]	text	jsmith@contoso.com
License types	[VAR:license_type]	select (enum)	E3, E5, F1
OU paths	[VAR:ou_path]	text	OU=Users,DC=contoso,DC=local
Port numbers	[VAR:port]	number	443
Subnet masks	[VAR:subnet_mask]	ip_address	255.255.255.0

---

11. Pricing & Tier Integration

KB Accelerator is a premium feature that justifies Pro and Team subscription pricing. The AI processing has a real per-conversion cost (Anthropic API usage), so tiering aligns expense with revenue.

Capability	Free	Pro ($19/mo)	Team ($15/user/mo)
Single article import	3 lifetime conversions	Unlimited	Unlimited
Batch import	Not available	Up to 10 articles	Up to 50 articles
Text paste	Included in 3 conversions	Unlimited	Unlimited
Target type selection	AI decides only	Manual + AI	Manual + AI
Review & edit	Basic (approve/reject)	Full (edit, regenerate, add)	Full + team review
Confidence scoring	Shown	Shown + filter/sort	Shown + filter/sort
Import history	Last 3 only	Full history	Full history + audit log
Supported formats	TXT and paste only	All formats	All formats

Free Tier Strategy

The free tier offers 3 lifetime conversions with limited formats. This is enough for a user to experience the value and see KB Accelerator work on their actual documentation. The restriction to TXT/paste on free tier also reduces extraction library dependencies for free-tier infrastructure cost optimization.

---

12. Build Phases & Roadmap

Phase 1: Foundation (Weeks 1–3)

Core pipeline with single-article import and basic review.

• Database migrations: kb_imports and kb_import_nodes tables, tree model extension
• Upload endpoint with text paste and TXT file support
• Text extraction service (plain text only in Phase 1)
• AI analysis prompt engineering and Phase 1 pipeline
• AI generation prompt engineering and Phase 2 pipeline (troubleshooting flow output only)
• Basic review UI: list view of generated nodes with approve/reject
• Commit endpoint that creates actual tree/node records

Phase 2: Rich Formats & Procedures (Weeks 4–6)

Full format support and procedure flow conversion.

• DOCX extraction via python-docx with structural metadata
• PDF extraction via PyMuPDF with layout analysis
• HTML extraction via BeautifulSoup
• Markdown extraction via markdown-it
• Procedure flow generation with variable detection and intake form generation
• Side-by-side review UI with source-to-node linking
• Per-node editing and regeneration in the review screen
• Confidence scoring visualization with left accent borders

Phase 3: Polish & Scale (Weeks 7–9)

Batch import, UX refinement, and tier enforcement.

• Batch upload endpoint and queue processing
• Import history dashboard with status tracking
• Tier gating enforcement (free tier limits, format restrictions)
• "Approve All High Confidence" bulk action
• Analytics: conversion success rate, average confidence, most-used source formats
• Drag-and-drop file upload zone with format badges
• "Let AI decide" target type recommendation

Phase 4: Advanced Intelligence (Future)

Stretch goals and post-launch enhancements.

• OCR fallback for scanned PDFs via Tesseract
• Multi-article correlation: detect when multiple KB articles describe the same issue from different angles and suggest merging
• Incremental re-import: detect when a source KB article has been updated and suggest flow updates
• ConnectWise/IT Glue/Hudu direct API integration for pulling articles without manual export
• Tag auto-assignment using the six-dimension tagging system based on article content analysis
• Template marketplace: share anonymized, high-confidence converted flows with the ResolutionFlow community

---

13. Risk Analysis

Risk	Severity	Impact	Mitigation
Poor quality KB input	Medium	AI produces low-confidence flows that require extensive manual editing, reducing perceived value	Confidence scoring sets expectations. "Needs Review" flags prevent silent bad output. Free tier lets users test before committing.
AI hallucination in flow logic	High	Generated flows contain incorrect troubleshooting paths that could lead technicians astray	Mandatory review step before commit. Source attribution shows exact text the AI based each node on. No auto-publish.
API cost overruns	Medium	High usage of AI analysis burns through API budget faster than subscription revenue covers	Per-conversion cost tracking. Tier limits on batch size. Prompt optimization to minimize token usage.
Extraction library maintenance	Low	python-docx, PyMuPDF, etc. may have breaking changes or security issues	Pin versions. Phase 1 starts with text-only to defer library dependency. Each format is an independent module.
User trust gap	High	Users don't trust AI-generated flows and abandon the feature after trying it once	Side-by-side source view builds trust. Confidence scoring is transparent. Start with high-quality conversion on well-structured articles to build initial trust.
Scope creep	Medium	Feature grows to include direct PSA integration, real-time sync, and other complex functionality before core is proven	Phased roadmap with clear scope boundaries. Phase 4 items are explicitly deferred until post-launch data validates demand.

---

14. Success Metrics

These KPIs determine whether KB Accelerator is delivering value to users and justifying its development investment.

Metric	Target	Why It Matters
Conversion completion rate	> 70%	Percentage of started imports that reach "committed" status. Below 70% suggests the review step is too burdensome or quality is too low.
Average confidence score	> 0.75	Across all generated nodes. Indicates the AI pipeline is producing reliably accurate output.
Time from upload to commit	< 10 minutes	The full cycle should feel fast. If users are spending 30+ minutes editing, the AI isn't saving enough time.
Free-to-Pro conversion rate	> 15%	Users who use their 3 free conversions and then upgrade. This validates that experiencing the feature drives subscription revenue.
Repeat usage (Pro/Team)	> 3 imports/month	Users who import once and never again didn't find sustained value. Repeat usage indicates the feature is part of their workflow.
Node edit rate	< 30%	Percentage of generated nodes that users edit before committing. Lower is better — means AI output is usable as-is.
Imported flow usage rate	> 50%	Percentage of committed flows that get used in actual troubleshooting sessions within 30 days. Unused flows mean the conversion produced shelfware.

---

End of Document

ResolutionFlow LLC — March 2026