Ideate

Ideate new business opportunities, features, and strategies with AI-powered tools and Business-as-Code patterns.

Overview

The Ideate phase is where business innovation begins. Using the .do platform's AI capabilities, semantic ontologies, and Business-as-Code patterns, you can rapidly generate, validate, and refine business ideas before investing in full development.

This phase transforms abstract concepts into structured, executable business models through:

AI-Powered Ideation: Generate business ideas using AI models
Semantic Validation: Verify ideas against industry ontologies and market data
Rapid Prototyping: Create minimal viable concepts without code
Business Model Canvas: Structure ideas using proven frameworks
Market Analysis: Validate against real market data and trends

Ideation Tools

AI-Powered Brainstorming

Generate and explore business ideas with AI:

// Generate business ideas
const ideas = await $.ai.generate('business-idea', {
  prompt: 'Generate SaaS business ideas for remote work collaboration',
  model: 'gpt-5',
  count: 10,
  constraints: {
    industry: ['Software', 'Technology'],
    businessModel: ['SaaS', 'Subscription'],
    targetMarket: ['B2B', 'SMB'],
  },
})

// Evaluate each idea
for (const idea of ideas) {
  const evaluation = await $.ai.evaluate(idea, {
    criteria: ['market-size', 'competition', 'feasibility', 'profitability'],
  })

  if (evaluation.score > 0.7) {
    await db.create($.Idea, {
      title: idea.title,
      description: idea.description,
      evaluation,
      status: 'promising',
    })
  }
}

Business Model Canvas

Structure your ideas using the Business Model Canvas:

// Create business model canvas
const canvas = await $.BusinessModel.create({
  idea: 'AI-powered project management tool',

  // Customer segments
  customerSegments: [
    { segment: 'Remote Teams', size: 'large', willingness: 'high' },
    { segment: 'Freelancers', size: 'medium', willingness: 'medium' },
  ],

  // Value propositions
  valuePropositions: [
    'AI-powered task prioritization',
    'Automated status updates',
    'Predictive deadline management',
  ],

  // Channels
  channels: ['Direct Sales', 'Self-Service', 'Partnerships'],

  // Revenue streams
  revenueStreams: [
    { type: 'Subscription', pricing: 'tiered', mrr: 29 },
    { type: 'Usage-based', pricing: 'per-user', mrr: 10 },
  ],

  // Key resources
  keyResources: ['AI Models', 'Development Team', 'Customer Data'],

  // Key partners
  keyPartners: ['Cloud Infrastructure', 'Payment Processors', 'Integration Partners'],
})

// Validate the business model
const validation = await $.BusinessModel.validate(canvas, {
  marketData: true,
  competitorAnalysis: true,
  financialProjections: true,
})

Semantic Market Research

Validate ideas against industry ontologies:

import { NAICS } from 'naics.org.ai'
import { ONET } from 'onet.org.ai'

// Analyze industry landscape
const industry = await $.Industry.analyze({
  naics: NAICS.Software_Publishers_511210,
  metrics: ['market-size', 'growth-rate', 'competition-level'],
})

// Identify target roles
const targetRoles = await $.Role.search({
  onet: [ONET.Software_Developers_15_1252, ONET.Project_Management_Specialists_13_1082],
  skills: ['AI', 'Automation', 'Project Management'],
})

// Analyze competitive landscape
const competitors = await $.Competitor.analyze({
  industry: NAICS.Software_Publishers_511210,
  keywords: ['project management', 'AI', 'automation'],
  metrics: ['funding', 'users', 'revenue'],
})

Ideation Workflows

1. Problem Discovery

Identify problems worth solving:

// Discover pain points
on($.User.submits.Feedback, async (feedback) => {
  // Analyze sentiment and themes
  const analysis = await $.ai.analyze(feedback.content, {
    extract: ['pain-points', 'feature-requests', 'frustrations'],
  })

  // Cluster similar problems
  for (const painPoint of analysis.painPoints) {
    const existing = await db.find($.Problem, {
      where: { description: { similar: painPoint, threshold: 0.8 } },
    })

    if (existing) {
      // Increment frequency
      await db.update($.Problem, existing.id, {
        frequency: existing.frequency + 1,
        examples: [...existing.examples, feedback],
      })
    } else {
      // Create new problem
      await db.create($.Problem, {
        description: painPoint,
        frequency: 1,
        source: 'user-feedback',
        examples: [feedback],
      })
    }
  }
})

// Prioritize problems by frequency and impact
const topProblems = await db.list($.Problem, {
  orderBy: { frequency: 'desc' },
  limit: 10,
})

2. Solution Brainstorming

Generate potential solutions:

// Generate solutions for each problem
for (const problem of topProblems) {
  const solutions = await $.ai.generate('solutions', {
    prompt: `Generate innovative solutions for: ${problem.description}`,
    count: 5,
    context: {
      industry: problem.industry,
      constraints: problem.constraints,
      existingSolutions: problem.currentWorkarounds,
    },
  })

  // Evaluate feasibility
  for (const solution of solutions) {
    const feasibility = await $.ai.evaluate(solution, {
      technical: { complexity: true, resources: true, timeline: true },
      business: { revenue: true, cost: true, marketFit: true },
      strategic: { alignment: true, differentiation: true, scalability: true },
    })

    await db.create($.Solution, {
      problem: problem.id,
      description: solution.description,
      approach: solution.approach,
      feasibility,
      status: feasibility.overall > 0.6 ? 'viable' : 'needs-work',
    })
  }
}

3. Rapid Validation

Test ideas quickly before building:

// Create landing page test
const landingPage = await $.LandingPage.create({
  idea: idea.id,
  headline: 'AI-Powered Project Management',
  subheadline: 'Let AI handle the busywork while you focus on what matters',
  cta: 'Join Waitlist',
  features: ['Smart Prioritization', 'Automated Updates', 'Predictive Insights'],
})

// Run ad campaign
const campaign = await $.Campaign.create({
  platform: 'google-ads',
  budget: 500,
  duration: '7 days',
  target: {
    audience: 'project-managers',
    keywords: ['project management', 'AI automation'],
  },
  destination: landingPage.url,
})

// Track validation metrics
on($.User.visits.LandingPage, async (event) => {
  await send($.Analytics.track, {
    event: 'landing-page-visit',
    ideaId: idea.id,
    source: event.source,
  })
})

on($.User.joins.Waitlist, async (user) => {
  await send($.Analytics.track, {
    event: 'waitlist-signup',
    ideaId: idea.id,
    conversionRate: await calculateConversion(idea.id),
  })

  // Interview interested users
  await send($.Email.send, {
    to: user.email,
    template: 'validation-interview',
    calendly: 'schedule-interview',
  })
})

Idea Evaluation Framework

Scoring System

Evaluate ideas systematically:

// Multi-dimensional evaluation
const evaluation = await $.Idea.evaluate(idea, {
  dimensions: {
    market: {
      weight: 0.3,
      factors: ['size', 'growth', 'accessibility'],
    },
    competition: {
      weight: 0.2,
      factors: ['intensity', 'differentiation', 'barriers'],
    },
    feasibility: {
      weight: 0.25,
      factors: ['technical', 'resources', 'timeline'],
    },
    impact: {
      weight: 0.25,
      factors: ['revenue-potential', 'strategic-fit', 'scalability'],
    },
  },
})

// Decision logic
if (evaluation.score >= 0.8) {
  await $.Idea.promote(idea, 'design-phase')
} else if (evaluation.score >= 0.6) {
  await $.Idea.flag(idea, 'needs-refinement')
} else {
  await $.Idea.archive(idea, 'low-score')
}

Ideation Patterns

Pattern 1: User-Driven Innovation

Let users drive ideation:

// Enable user idea submission
on($.User.submits.Idea, async (submission) => {
  const idea = await db.create($.Idea, {
    title: submission.title,
    description: submission.description,
    submittedBy: submission.user,
    status: 'community-review',
  })

  // Enable community voting
  await send($.Community.notify, {
    type: 'new-idea',
    idea,
    action: 'vote',
  })
})

// Track votes
on($.User.votes.Idea, async (vote) => {
  const idea = await db.get($.Idea, vote.ideaId)
  const totalVotes = await db.count($.Vote, { where: { ideaId: idea.id } })

  if (totalVotes > 100) {
    // Promote popular ideas
    await $.Idea.promote(idea, 'team-review')
  }
})

Pattern 2: Data-Driven Opportunities

Discover opportunities from data:

// Analyze usage patterns
on($.Analytics.detects.Anomaly, async (anomaly) => {
  if (anomaly.type === 'increased-usage') {
    // Investigate opportunity
    const opportunity = await $.ai.analyze(anomaly, {
      question: 'Why is this feature suddenly popular?',
      context: await getRecentEvents(),
    })

    // Create idea
    await db.create($.Idea, {
      title: `Expand ${anomaly.feature} based on usage spike`,
      description: opportunity.hypothesis,
      evidence: anomaly.data,
      source: 'data-driven',
      status: 'investigate',
    })
  }
})

Pattern 3: Competitive Monitoring

Track competitor moves:

// Monitor competitor announcements
on($.Competitor.announces.Feature, async (announcement) => {
  // Analyze competitive threat
  const analysis = await $.ai.analyze(announcement, {
    assess: ['threat-level', 'differentiation', 'response-options'],
  })

  if (analysis.threatLevel === 'high') {
    // Generate response ideas
    const responses = await $.ai.generate('competitive-response', {
      competitor: announcement.competitor,
      feature: announcement.feature,
      strategy: 'differentiate',
    })

    for (const response of responses) {
      await db.create($.Idea, {
        title: response.title,
        description: response.description,
        type: 'competitive-response',
        urgency: 'high',
      })
    }
  }
})

Collaboration Tools

Team Brainstorming

Facilitate collaborative ideation:

# Start ideation session
do ideate session start --topic "New revenue streams"

# Participants submit ideas
do ideate submit --idea "Usage-based pricing tier"

# Vote on ideas
do ideate vote --session current

# Export top ideas
do ideate export --format canvas --top 5

Stakeholder Input

Gather input from stakeholders:

// Request stakeholder feedback
const feedback = await $.Stakeholder.requestFeedback({
  idea,
  questions: [
    'Does this align with our strategic priorities?',
    'What risks do you foresee?',
    'What resources would this require?',
  ],
  deadline: '7 days',
})

// Aggregate responses
on($.Stakeholder.submits.Feedback, async (response) => {
  const aggregated = await $.Feedback.aggregate(idea.id)

  if (aggregated.consensus > 0.7) {
    await $.Idea.approve(idea)
  }
})

Best Practices

Do's

Generate volume first - Create many ideas before filtering
Use data - Ground ideas in real problems and opportunities
Validate early - Test before building
Involve users - Get customer input early
Think big - Don't self-censor during brainstorming
Be systematic - Use frameworks and scoring
Document everything - Capture all ideas for future reference

Don'ts

Don't fall in love - Be willing to kill ideas
Don't skip validation - Assuming demand is risky
Don't ignore data - Trust evidence over intuition
Don't go alone - Diverse perspectives improve ideas
Don't rush - Proper ideation saves development time
Don't forget constraints - Consider resources and feasibility

From Ideation to Design

Once you have validated ideas, move to the Design phase:

// Promote idea to design phase
const designProject = await $.Idea.promote(idea, 'design', {
  assignTeam: 'product-design',
  createEpic: true,
  schedule: 'next-sprint',
})

// Initialize business model
await $.BusinessModel.initialize(designProject, {
  canvas: idea.businessCanvas,
  requirements: idea.requirements,
  constraints: idea.constraints,
})

CLI Tools

# Generate ideas
do ideate generate --prompt "SaaS for construction" --count 10

# Evaluate idea
do ideate evaluate idea-123 --detailed

# Create business canvas
do ideate canvas --idea idea-123

# Run validation campaign
do ideate validate idea-123 --budget 500 --duration 7d

# Export ideas
do ideate export --format csv --status promising

Next Steps

Design → - Transform ideas into executable specifications
Business Modeling → - Create detailed business models
Semantic Patterns → - Learn semantic modeling

Ideation Tip: The best ideas come from real problems. Start with pain points, not solutions.

Ideate

On this page