> This page is for version v8.3.0 (default). > For other versions, use one of these documentation indexes: > - v8.3.0 (default): https://docs.workflows.com/v-8-3-0/llms.txt > For clean Markdown of any page, append .md to the page URL. > For a complete documentation index, see https://docs.workflows.com/llms.txt. > For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.workflows.com/_mcp/server. # Align Stakeholders & Launch ![Mind Reasoner](/_fern-files/_img/466e07efd0202b28f29ec8dda3be88918c85104c2652efceb8ff717127f861ca.webp) > **Stop Shipping into the Void** > > **The shift:** Create minds for users, executives, and internal stakeholders. Predict all their concerns. Navigate approvals systematically. Ship features that succeed. > > **Result:** Get features shipped faster with higher adoption and fewer surprises post-launch. --- ## Two Complex Scenarios #### Internal Approvals **The challenge:** * Engineering leadership questions feasibility * Sales needs different packaging * Support worries about training burden * Executives flag budget concerns * One blocker kills the roadmap **The solution:** * Create mind for EACH stakeholder * Predict each person's concerns * Know who will champion vs. block * Address concerns before meetings **Outcome:** Navigate internal complexity. Ship faster. #### Launch Success **The challenge:** * Users don't adopt the feature * You don't know what went wrong * Missed requirements post-launch * Expensive fixes and redesigns **The solution:** * Predict user adoption barriers * Test messaging and positioning * Validate requirements pre-build * Know success metrics that matter **Outcome:** Higher adoption. Fewer surprises. Better launches. --- ## Navigate Internal Stakeholders ### 1. Create Stakeholder Minds One mind for EACH internal decision-maker: ```bash > "SCENARIO: You're preparing for a roadmap approval meeting with multiple internal stakeholders. Each has different concerns about the proposed feature. QUESTION: Create minds for: 1) VP Engineering, 2) CRO (Sales), 3) VP Customer Success using their past discussion transcripts." ``` **Training:** 5-15 minutes per stakeholder ### 2. Predict Each Stakeholder's Concerns Ask EACH stakeholder mind: ```bash > "SCENARIO: The product team is proposing to build [feature] in Q2. This requires budget allocation and will impact your team's priorities. QUESTION: What are YOUR concerns about this proposal? What would make you support or block this?" ``` **You'll know:** Engineering's feasibility concerns, Sales' packaging needs, Support's training worries, who will champion vs. block ### 3. Address Concerns Systematically Prepare stakeholder-specific approaches: * Engineering needs: Technical spec + resource plan * Sales needs: Competitive positioning + pricing tier * Support needs: Training materials + documentation Enter roadmap meetings knowing what EACH person needs. ### Real Example: Internal Stakeholder Alignment #### The Problem **Without stakeholder minds:** You propose building advanced analytics in roadmap meeting. **VP Engineering:** * "This will take 3 engineers for 6 months" * You: *\[didn't anticipate scope concerns]* **CRO (Sales):** * "Which tier? Will this help us close enterprise deals?" * You: *\[don't have pricing strategy ready]* **VP Customer Success:** * "Our team doesn't know how to support analytics features" * You: *\[didn't plan for training]* **Result:** Feature blocked. Goes back to drawing board. 2-month delay. #### The Solution **With stakeholder minds:** ### Before Roadmap Meeting **Ask VP Engineering mind:** ```bash > "We're proposing to build advanced analytics in Q2. What are your concerns about this?" ``` **VP Engineering mind predicts:** ``` My concerns: 1. Scope: "Advanced analytics" is too vague What I need: Detailed spec with defined scope Risk: Scope creep kills timelines 2. Resources: This sounds like 6-month project What I need: Resource justification Risk: Pulls engineers from other priorities 3. Technical Debt: Our data pipeline isn't ready What I need: Infrastructure plan first Risk: Build on shaky foundation What I need to support this: - Detailed technical spec (2-3 pages) - Phased roadmap (MVP → Full feature) - Infrastructure investment plan - Clear resource allocation With these, I'll support it. Without, I'll block it. ``` **Ask CRO (Sales) mind:** ```bash > "Same question: advanced analytics feature for Q2?" ``` **CRO mind predicts:** ``` My concerns: 1. Competitive Positioning: Are we catching up or leading? What I need: How does this compare to competitors? Risk: "Me too" feature doesn't help us win 2. Pricing/Packaging: Which tier? What I need: Enterprise-only to drive upgrades Risk: Wrong packaging leaves revenue on table 3. Sales Enablement: How do I sell this? What I need: Value prop + use cases + demo Risk: Sales team won't know how to position it What I need to support this: - Competitive analysis - Enterprise tier pricing - 3 customer stories/use cases - Demo environment for sales With these, I'll champion it. Without, I'm neutral. ``` **Ask VP Customer Success mind:** ```bash > "Same question: advanced analytics feature?" ``` **VP CS mind predicts:** ``` My concerns: 1. Training Burden: My team doesn't know analytics What I need: Training plan + timeline Risk: Support tickets we can't handle 2. Documentation: Will docs be ready at launch? What I need: Help docs before feature ships Risk: Customers confused, no answers 3. Change Management: How do we roll this out? What I need: Beta program + gradual rollout Risk: Poor launch experience What I need to support this: - 2-week training for support team - Complete documentation pre-launch - Beta program (20 customers) - Gradual rollout plan With these, I'll support it. Without, I'll raise concerns. ``` ### Prepare for Meeting **You now know:** * Engineering needs: Technical spec + phased plan + infrastructure * Sales needs: Competitive analysis + Enterprise tier + use cases * CS needs: Training + documentation + beta program ### In Actual Roadmap Meeting **VP Engineering:** "What's the scope?" * You: *\[presents technical spec + phased roadmap]* * VP Eng: "Good. Let's do MVP first, then expand." **CRO:** "Which tier and how do we sell it?" * You: *\[presents competitive positioning + Enterprise tier strategy]* * CRO: "Perfect. This will help us close enterprise deals." **VP CS:** "How will we support this?" * You: *\[presents training plan + beta program]* * VP CS: "Works for me. Let's do the beta." **Result:** Feature approved. Clear execution plan. No delays. --- ## Optimize Launch Success ### 1. Create User Segment Minds Upload transcripts from different user segments: ```bash > "SCENARIO: You're preparing to launch a new feature to multiple user segments (Power users, Casual users, Enterprise users). Each segment has different adoption barriers. QUESTION: Create user minds for: 1) Power users, 2) Casual users, 3) Enterprise users using their interview transcripts." ``` **Training:** 5-15 minutes per segment ### 2. Predict Adoption Barriers Ask EACH segment mind: ```bash > "SCENARIO: The product team is launching [feature] next month. They're asking for your feedback on potential concerns before finalizing the launch plan. QUESTION: What concerns would you have about this feature? What would prevent you from using it?" ``` **Identify:** Segment-specific adoption barriers, required features for each segment, messaging that resonates, success metrics that matter ### 3. Optimize Pre-Launch Address barriers before launch: * Build segment-specific requirements * Create targeted messaging * Plan rollout strategy by segment * Set realistic success metrics Launch with confidence. Higher adoption. ### Real Example: Launch Optimization #### The Problem **Without user minds:** You launch new collaboration feature. **Week 1:** 15% adoption rate **Week 4:** 18% adoption rate (stalled) **Post-mortem reveals:** * Enterprise users: "No permission controls—can't use it" * Power users: "Notification overload—turned it off" * Casual users: "Too complicated—don't need it" **Result:** Feature failed. Expensive fixes. Redesign required. #### The Solution **With user segment minds:** ### Before Launch **Ask Enterprise user mind:** ```bash > "We're launching collaboration features. What concerns would prevent you from using it?" ``` **Enterprise mind predicts:** ``` Adoption blockers: 1. Permission Controls: Who can see what? Why: We have sensitive client data Without this: Won't enable it (security risk) 2. Compliance: SOC 2 / GDPR considerations Why: We're in healthcare Without this: Legal won't approve 3. Admin Controls: Can I manage team access? Why: Need centralized control Without this: Adoption chaos Requirements for adoption: - Project-level permissions - Audit logs for compliance - Admin dashboard - SSO integration Without these: 0% adoption from enterprise segment With these: 80%+ adoption (solves real problem) ``` **Ask Power user mind:** ```bash > "Same question: collaboration feature concerns?" ``` **Power user mind predicts:** ``` Adoption blockers: 1. Notification Fatigue: Will I get spammed? Why: I already ignore most notifications Without smart defaults: Turn off day 1 2. Performance: Will it slow down the app? Why: I work fast, need speed Without performance: Disable it 3. Keyboard Shortcuts: Can I collaborate without mouse? Why: I live in keyboard shortcuts Without this: Won't adopt into workflow Requirements for adoption: - @mentions only (default) - No performance impact - Full keyboard navigation - Slack-style shortcuts Without these: 20% adoption (too much friction) With these: 90%+ adoption (enhances my workflow) ``` **Ask Casual user mind:** ```bash > "Same question: collaboration feature concerns?" ``` **Casual user mind predicts:** ``` Adoption blockers: 1. Complexity: Looks complicated Why: I use 10% of current features Without simplicity: Won't learn it 2. Value Prop: Why do I need this? Why: I work solo mostly Without clear use case: Ignore it 3. Discovery: Where do I find it? Why: I rarely explore new features Without prominent placement: Never discover it Requirements for adoption: - Simple 1-2-3 onboarding - Clear solo use cases - In-app prompts/tips - Optional, not forced Without these: 5% adoption (don't see value) With these: 30% adoption (clear value prop) ``` ### Optimize Before Launch **Segment-specific requirements:** **Enterprise (high-value):** * Build: Project permissions + audit logs + admin controls * Result: 80% adoption (critical needs met) **Power users (high-engagement):** * Build: Smart defaults + keyboard shortcuts + performance * Result: 90% adoption (enhances workflow) **Casual users (large volume):** * Build: Simple onboarding + clear use cases + optional * Result: 30% adoption (realistic for segment) ### Launch Results **Week 1:** * Enterprise: 75% adoption (permission controls worked) * Power users: 85% adoption (keyboard shortcuts loved) * Casual users: 28% adoption (realistic for segment) **Week 4:** * Enterprise: 88% adoption (word-of-mouth growth) * Power users: 92% adoption (became core workflow) * Casual users: 35% adoption (steady growth) **Overall:** 65% adoption across all segments **Result:** Successful launch. No redesign needed. Adoption exceeded goals. --- ## Common Complex Scenarios **Roadmap Prioritization**: Predict which features users will actually adopt, understand stakeholder support, know engineering complexity. Build the right features in the right order, maximize ROI. **Pricing Decisions**: Predict willingness to pay by segment, understand which tier each segment expects, know upgrade drivers. Maximize revenue with right pricing and packaging. **Technical Debt vs. Features**: Predict user impact of technical issues, understand engineering constraints, know customer pain points. Make informed tradeoffs between debt and features. **Sunset Old Features**: Predict which users will be impacted, understand migration path acceptance, know communication that softens blow. Successful sunsetting with minimal backlash. **Competitive Response**: Predict if users actually care about competitor feature, understand differentiation from user perspective, know switching risk. Respond to real threats, ignore noise, stay differentiated. **Launch Timing**: Predict user acceptance of MVP vs. full feature, understand adoption barriers, know stakeholder pressure. Launch at right time with right scope for success. --- ## Implementation #### MCP (No Code) **Use Mind Reasoner through Claude Code** No coding. Just natural conversation in Claude. ### Internal Stakeholder Example **You:** ```bash > Create stakeholder minds for feature approval: 1. VP Engineering - /calls/eng-planning.vtt 2. CRO (Sales) - /calls/sales-feedback.vtt 3. VP Customer Success - /calls/cs-reviews.vtt ``` **Mind Reasoner:** ``` ✓ Training 3 stakeholder minds... (~10 min each) ``` **You:** ```bash > We're proposing to build advanced analytics in Q2. Ask each stakeholder: What are your concerns? What would make you support or block this? ``` **Mind Reasoner:** ``` VP Engineering's concerns: - Scope too vague (needs detailed spec) - Resource intensive (6-month project) - Infrastructure not ready (data pipeline needs work) Needs: Technical spec + phased plan + infrastructure investment CRO's concerns: - Competitive positioning unclear - Pricing/packaging undecided - Sales enablement needed Needs: Competitive analysis + Enterprise tier + customer stories VP CS's concerns: - Team training required - Documentation timeline - Rollout strategy needed Needs: Training plan + docs pre-launch + beta program You're ready for roadmap meeting with all concerns addressed. ``` ### Launch Optimization Example **You:** ```bash > Create user segment minds: 1. Enterprise - /research/enterprise-interviews.vtt 2. Power users - /research/power-user-feedback.vtt 3. Casual users - /research/casual-user-calls.vtt ``` **Mind Reasoner:** ``` ✓ Training 3 segment minds... (~10 min each) ``` **You:** ```bash > We're launching collaboration features next month. Ask each segment: What concerns would prevent you from using it? What would make you adopt it? ``` **Mind Reasoner:** ``` Enterprise segment: Blockers: No permission controls, compliance concerns, no admin controls Requirements: Project permissions + audit logs + admin dashboard Predicted adoption: 0% without requirements, 80% with requirements Power user segment: Blockers: Notification overload, performance concerns, no keyboard shortcuts Requirements: Smart defaults + no performance impact + keyboard navigation Predicted adoption: 20% without requirements, 90% with requirements Casual user segment: Blockers: Looks complicated, unclear value prop, hard to discover Requirements: Simple onboarding + clear use cases + in-app prompts Predicted adoption: 5% without requirements, 30% with requirements Recommendation: Build Enterprise + Power user requirements for launch. These are high-value, high-adoption segments. Optimize Casual later. ``` [MCP Tools Reference →](/mcp-tools) #### Direct API **Build stakeholder prediction into your workflow** ```javascript const API_BASE = 'https://api.reasoner.com/api/mindsim'; // Create stakeholder minds for approval process const stakeholders = [ { role: 'VP Engineering', mindId: 'mind_eng' }, { role: 'CRO', mindId: 'mind_sales' }, { role: 'VP CS', mindId: 'mind_cs' } ]; // Predict each stakeholder's concerns const stakeholderAnalysis = await Promise.all( stakeholders.map(async ({ role, mindId }) => { const response = await fetch(`${API_BASE}/simulate`, { method: 'POST', headers: { 'Authorization': `Bearer ${API_KEY}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ mindId, scenario: { message: "We're proposing advanced analytics for Q2. What are your concerns? What would make you support or block this?" } }) }).then(r => r.json()); return { role, concerns: response.message }; }) ); console.log('Stakeholder concerns:', stakeholderAnalysis); // Predict user segment adoption const userSegments = [ { segment: 'Enterprise', mindId: 'mind_ent' }, { segment: 'Power users', mindId: 'mind_power' }, { segment: 'Casual users', mindId: 'mind_casual' } ]; const adoptionPredictions = await Promise.all( userSegments.map(async ({ segment, mindId }) => { const response = await fetch(`${API_BASE}/simulate`, { method: 'POST', headers: { 'Authorization': `Bearer ${API_KEY}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ mindId, scenario: { message: "We're launching collaboration features. What concerns would prevent you from using it? What would make you adopt it?" } }) }).then(r => r.json()); return { segment, prediction: response.message }; }) ); console.log('Adoption predictions:', adoptionPredictions); ``` [API Documentation →](/api-quick-start) --- ## Next Steps #### [Validate Features & Designs](/workflow-product-validate-features) Learn to validate features and designs before building #### [MCP Quick Start](/mcp-quickstart) Set up in 5 minutes #### [API Quick Start](/api-quick-start) Build into your product workflow > **Info** > > Questions? Email [support@reasoner.com](mailto:support@reasoner.com)