Startup Composition

One of the key advantages of Business-as-Code is composability - building complex startups by assembling reusable, tested building blocks. Instead of building everything from scratch, you compose pre-built components that already work.

The Composition Model

Traditional startups require building everything:

Custom code for every feature
Bespoke integrations
Manual processes
Unique infrastructure

Business-as-Code startups compose from blocks:

Import existing components via URLs
Extend and customize as needed
Inherit tested functionality
Focus on differentiation

Building Block Types

1. Products

Pre-built product types with common patterns:

import { SaaSProduct } from 'https://products.do/saas'
import { Marketplace } from 'https://products.do/marketplace'
import { APIProduct } from 'https://products.do/api'
import { DataProduct } from 'https://products.do/data'

// SaaS Product
export const product = new SaaSProduct({
  name: 'Analytics Platform',
  features: ['dashboards', 'reports', 'alerts'],
  pricing: {
    model: 'usage-based',
    tiers: [
      { name: 'starter', basePrice: 49, included: 10000 },
      { name: 'growth', basePrice: 199, included: 100000 },
      { name: 'enterprise', basePrice: 999, included: 'unlimited' }
    ]
  }
})

// Marketplace
export const marketplace = new Marketplace({
  name: 'Designer Marketplace',
  supply: 'designers',
  demand: 'businesses',
  commission: 0.15,
  paymentFlow: 'escrow'
})

2. Sites

Marketing sites from templates:

import { SaaSLanding } from 'https://sites.do/saas-landing'
import { MarketplaceLanding } from 'https://sites.do/marketplace-landing'
import { DocsTemplate } from 'https://sites.do/docs'
import { BlogTemplate } from 'https://sites.do/blog'

export const site = new SaaSLanding({
  hero: {
    headline: 'AI-Powered Analytics',
    subheadline: 'Get insights in minutes, not weeks',
    cta: 'Start Free Trial'
  },
  sections: ['hero', 'features', 'social-proof', 'pricing', 'faq', 'cta'],
  theme: 'modern-gradient'
})

export const docs = new DocsTemplate({
  sections: ['getting-started', 'api', 'guides', 'reference'],
  search: true,
  versions: true
})

3. Apps

Authenticated product experiences:

import { DashboardApp } from 'https://apps.do/dashboard'
import { AdminPanel } from 'https://apps.do/admin'
import { AnalyticsDashboard } from 'https://apps.do/analytics'

export const app = new DashboardApp({
  sidebar: {
    sections: [
      { title: 'Overview', icon: 'Home', route: '/' },
      { title: 'Analytics', icon: 'BarChart', route: '/analytics' },
      { title: 'Settings', icon: 'Settings', route: '/settings' }
    ]
  },
  features: ['dashboard', 'reports', 'settings', 'team', 'billing']
})

4. Functions

Executable logic blocks:

import { validateEmail } from 'https://functions.do/validation/email'
import { sendEmail } from 'https://functions.do/email/send'
import { processPayment } from 'https://functions.do/payments/stripe'
import { generateInvoice } from 'https://functions.do/invoicing/create'

// Use directly
export async function onSignup(email: string) {
  if (!validateEmail(email)) {
    throw new Error('Invalid email')
  }

  await sendEmail({
    to: email,
    template: 'welcome',
    data: { name: user.name }
  })
}

// Compose into workflows
export async function processOrder(order: Order) {
  const payment = await processPayment(order.total, order.paymentMethod)
  const invoice = await generateInvoice(order, payment)
  await sendEmail({
    to: order.customer.email,
    template: 'invoice',
    data: { invoice }
  })
  return { payment, invoice }
}

5. Agents

AI agents for operations:

import { SalesAgent } from 'https://agents.do/sales'
import { SupportAgent } from 'https://agents.do/support'
import { MarketingAgent } from 'https://agents.do/marketing'
import { ResearchAgent } from 'https://agents.do/research'

export const agents = {
  sales: new SalesAgent({
    name: 'Alex',
    personality: 'professional-friendly',
    capabilities: ['qualify-leads', 'send-outreach', 'book-meetings'],
    tools: ['crm', 'email', 'calendar'],
    rules: [
      'Only reach out to qualified leads (score > 70)',
      'Personalize every message based on company research',
      'Follow up max 3 times over 2 weeks'
    ]
  }),

  support: new SupportAgent({
    name: 'Sam',
    personality: 'helpful-patient',
    capabilities: ['answer-questions', 'troubleshoot', 'escalate'],
    tools: ['knowledge-base', 'ticketing', 'slack'],
    escalationRules: [
      'Escalate billing issues immediately',
      'Escalate if customer sentiment drops below 3/5',
      'Escalate after 3 failed resolution attempts'
    ]
  })
}

6. Integrations

Third-party service connections:

import { StripeIntegration } from 'https://integrations.do/stripe'
import { SendGridIntegration } from 'https://integrations.do/sendgrid'
import { Auth0Integration } from 'https://integrations.do/auth0'
import { AnalyticsIntegration } from 'https://integrations.do/analytics'

export const integrations = {
  payments: new StripeIntegration({
    mode: 'live',
    webhooks: ['payment.succeeded', 'subscription.updated'],
    products: product.pricing.tiers.map(tier => tier.stripeId)
  }),

  email: new SendGridIntegration({
    templates: ['welcome', 'invoice', 'password-reset'],
    fromEmail: 'hello@acme.com',
    fromName: 'Acme Team'
  }),

  auth: new Auth0Integration({
    providers: ['google', 'github', 'email'],
    mfa: true,
    passwordRules: { minLength: 12, requireSpecialChar: true }
  })
}

Composition Patterns

Pattern 1: Extend and Override

Start with a base component and customize:

import { SaaSProduct } from 'https://products.do/saas'

// Extend base SaaS product
export const product = new SaaSProduct({
  ...SaaSProduct.defaults,

  // Override specific properties
  name: 'Custom Analytics',

  // Add custom features
  features: [
    ...SaaSProduct.defaults.features,
    'custom-dashboards',
    'white-labeling'
  ],

  // Override pricing
  pricing: {
    model: 'hybrid', // base + usage
    basePrice: 99,
    usage: {
      metric: 'api-calls',
      price: 0.001,
      included: 100000
    }
  }
})

Pattern 2: Compose Multiple Blocks

Combine several components:

import { SaaSProduct } from 'https://products.do/saas'
import { APIProduct } from 'https://products.do/api'
import { DataProduct } from 'https://products.do/data'

// Multi-product startup
export const products = {
  // Main SaaS product
  dashboard: new SaaSProduct({
    name: 'Analytics Dashboard',
    features: ['visualizations', 'reports', 'alerts']
  }),

  // API for developers
  api: new APIProduct({
    name: 'Analytics API',
    endpoints: ['query', 'export', 'webhooks'],
    pricing: { model: 'usage-based', price: 0.001 }
  }),

  // Data product for power users
  data: new DataProduct({
    name: 'Raw Data Access',
    format: ['csv', 'json', 'parquet'],
    pricing: { model: 'subscription', price: 499 }
  })
}

Pattern 3: Wrap and Enhance

Add capabilities to existing blocks:

import { SupportAgent } from 'https://agents.do/support'

// Enhanced support agent with custom tools
export const support = new SupportAgent({
  ...SupportAgent.defaults,

  // Add custom tools
  tools: [
    ...SupportAgent.defaults.tools,
    {
      name: 'check-server-status',
      description: 'Check if our servers are operational',
      function: async () => {
        const status = await fetch('https://status.acme.com/api/health')
        return status.json()
      }
    },
    {
      name: 'refund-order',
      description: 'Process a refund for an order',
      function: async (orderId: string) => {
        // Custom refund logic
        return processRefund(orderId)
      }
    }
  ]
})

Pattern 4: Template Instantiation

Use templates with your data:

import { StartupTemplate } from 'https://templates.do/startup-saas'

export const startup = new StartupTemplate({
  // Your business details
  business: {
    name: 'Acme Analytics',
    tagline: 'Analytics for e-commerce',
    vertical: 'B2B SaaS',
    stage: 'Build'
  },

  // Template automatically creates:
  // - Marketing site
  // - Product app
  // - Documentation
  // - API
  // - Basic agents (sales, support)

  // You just customize specifics
  product: {
    features: ['dashboards', 'reports', 'alerts'],
    pricing: [
      { tier: 'starter', price: 99 },
      { tier: 'growth', price: 299 },
      { tier: 'enterprise', price: 999 }
    ]
  }
})

Example: Complete SaaS Startup

Here's a full example composing a SaaS startup:

---
$context: https://schema.org.ai
$type: Startup
$id: https://acme-analytics.com
name: Acme Analytics
tagline: AI-powered analytics for e-commerce
stage: Build
vertical: B2B SaaS
---

# {name}

{tagline}

## Composition

import { SaaSProduct } from 'https://products.do/saas'
import { SaaSLanding } from 'https://sites.do/saas-landing'
import { DashboardApp } from 'https://apps.do/dashboard'
import { DocsTemplate } from 'https://sites.do/docs'
import { APIProduct } from 'https://products.do/api'

import { SalesAgent } from 'https://agents.do/sales'
import { SupportAgent } from 'https://agents.do/support'
import { MarketingAgent } from 'https://agents.do/marketing'

import { StripeIntegration } from 'https://integrations.do/stripe'
import { SendGridIntegration } from 'https://integrations.do/sendgrid'
import { AnalyticsIntegration } from 'https://integrations.do/analytics'

### Product

export const product = new SaaSProduct({
  name: 'Acme Analytics',
  description: 'Turn your e-commerce data into actionable insights',
  features: [
    'real-time-dashboards',
    'trend-detection',
    'churn-prediction',
    'custom-reports',
    'alerts-notifications'
  ],
  pricing: {
    model: 'tiered',
    tiers: [
      {
        name: 'Starter',
        price: 99,
        limits: { orders: 1000, stores: 1 }
      },
      {
        name: 'Growth',
        price: 299,
        limits: { orders: 10000, stores: 3 }
      },
      {
        name: 'Enterprise',
        price: 999,
        limits: { orders: 'unlimited', stores: 'unlimited' }
      }
    ]
  }
})

### Site (Marketing)

export const site = new SaaSLanding({
  domain: 'acme-analytics.com',
  hero: {
    headline: 'Turn Data Into Growth',
    subheadline: 'AI-powered analytics that predict trends and prevent churn',
    cta: { text: 'Start Free Trial', action: '/signup' },
    image: '/hero-dashboard.png'
  },
  sections: [
    'hero',
    'social-proof',
    'features',
    'how-it-works',
    'pricing',
    'testimonials',
    'faq',
    'cta'
  ],
  theme: 'modern-gradient',
  colors: {
    primary: '#3B82F6',
    secondary: '#8B5CF6'
  }
})

### App (Product Dashboard)

export const app = new DashboardApp({
  domain: 'app.acme-analytics.com',
  layout: 'sidebar',
  navigation: [
    { title: 'Dashboard', icon: 'LayoutDashboard', route: '/' },
    { title: 'Reports', icon: 'FileText', route: '/reports' },
    { title: 'Alerts', icon: 'Bell', route: '/alerts' },
    { title: 'Integrations', icon: 'Plug', route: '/integrations' },
    { title: 'Settings', icon: 'Settings', route: '/settings' }
  ],
  features: [
    'dashboard',
    'custom-reports',
    'real-time-alerts',
    'team-management',
    'api-keys',
    'billing'
  ]
})

### Documentation

export const docs = new DocsTemplate({
  domain: 'docs.acme-analytics.com',
  sections: [
    {
      title: 'Getting Started',
      pages: ['installation', 'quickstart', 'connect-store']
    },
    {
      title: 'Features',
      pages: ['dashboards', 'reports', 'alerts', 'integrations']
    },
    {
      title: 'API',
      pages: ['authentication', 'endpoints', 'webhooks', 'rate-limits']
    }
  ],
  search: true,
  versions: ['v1', 'v2']
})

### API

export const api = new APIProduct({
  domain: 'api.acme-analytics.com',
  version: 'v2',
  endpoints: [
    { path: '/query', method: 'POST', auth: 'api-key' },
    { path: '/reports', method: 'GET', auth: 'api-key' },
    { path: '/export', method: 'POST', auth: 'api-key' },
    { path: '/webhooks', method: 'POST', auth: 'api-key' }
  ],
  rateLimit: { requests: 1000, window: '1h' }
})

### AI Agents

export const agents = {
  sales: new SalesAgent({
    name: 'Alex Sales',
    capabilities: ['qualify-leads', 'send-outreach', 'book-demos'],
    tools: ['crm', 'email', 'calendar'],
    rules: [
      'Target Shopify/WooCommerce stores doing $50k+/year',
      'Personalize outreach based on store category',
      'Offer free analytics report as lead magnet'
    ]
  }),

  support: new SupportAgent({
    name: 'Sam Support',
    capabilities: ['answer-questions', 'troubleshoot', 'escalate'],
    tools: ['knowledge-base', 'ticketing', 'slack'],
    hoursAvailable: '24/7',
    escalationRules: [
      'Escalate data accuracy issues immediately',
      'Escalate integration failures within 1 hour',
      'Escalate if customer sentiment < 3/5'
    ]
  }),

  marketing: new MarketingAgent({
    name: 'Morgan Marketing',
    capabilities: ['create-content', 'manage-campaigns', 'analyze-performance'],
    tools: ['blog', 'email-marketing', 'social-media', 'analytics'],
    campaigns: [
      { name: 'SEO Content', frequency: 'weekly', channels: ['blog'] },
      { name: 'Email Newsletter', frequency: 'monthly', channels: ['email'] },
      { name: 'Case Studies', frequency: 'quarterly', channels: ['blog', 'social'] }
    ]
  })
}

### Integrations

export const integrations = {
  payments: new StripeIntegration({
    products: product.pricing.tiers.map(tier => ({
      name: tier.name,
      price: tier.price
    })),
    webhooks: ['payment.succeeded', 'subscription.updated', 'subscription.deleted']
  }),

  email: new SendGridIntegration({
    templates: [
      'welcome',
      'trial-ending',
      'usage-alert',
      'invoice',
      'weekly-insights'
    ],
    fromEmail: 'team@acme-analytics.com'
  }),

  analytics: new AnalyticsIntegration({
    provider: 'plausible',
    domains: [site.domain, app.domain, docs.domain]
  }),

  // E-commerce platform integrations
  ecommerce: {
    shopify: { enabled: true, scopes: ['read_orders', 'read_customers'] },
    woocommerce: { enabled: true, scopes: ['read'] },
    bigcommerce: { enabled: true, scopes: ['read'] }
  }
}

## Business Model

<LeanCanvas
  problem="E-commerce stores can't predict trends or prevent churn"
  solution="AI analytics that automatically identifies patterns"
  uniqueValueProp="Predictions, not just dashboards"
  unfairAdvantage="Proprietary churn prediction algorithm"
  customerSegments="Shopify/WooCommerce stores $50k-$5M/year"
  channels="Product-led growth, content marketing, partnerships"
  costStructure="AI compute, hosting, development"
  revenueStreams="SaaS subscriptions, API usage"
/>

## Metrics

<Metrics
  mrr={2000}
  customers={20}
  churnRate={0.05}
  ltv={800}
  cac={200}
/>

## Links

- **Site**: https://acme-analytics.com
- **App**: https://app.acme-analytics.com
- **Docs**: https://docs.acme-analytics.com
- **API**: https://api.acme-analytics.com
- **Status**: https://status.acme-analytics.com

This complete startup is composed from:

1 product template (SaaSProduct)
4 site/app templates
3 AI agents
4 integrations

All working together as a coherent business.

Benefits of Composition

Speed

Compose in hours instead of building over months

Quality

Use battle-tested components instead of untested custom code

Consistency

Every startup follows proven patterns

Maintainability

Updates to base components improve all startups using them

Scalability

Launch 10 startups as easily as 1

Focus

Spend time on differentiation, not infrastructure

Creating Your Own Building Blocks

You can create reusable blocks for others:

---
$type: ProductTemplate
$id: https://products.do/analytics-dashboard
name: Analytics Dashboard Template
---

# Analytics Dashboard Template

Reusable analytics dashboard for any SaaS product.

export function createAnalyticsDashboard(config: DashboardConfig) {
  return {
    widgets: [
      { type: 'metric', label: 'Total Users', query: config.usersQuery },
      { type: 'chart', label: 'Growth', query: config.growthQuery },
      { type: 'table', label: 'Recent Activity', query: config.activityQuery }
    ],
    layout: config.layout || 'grid',
    refreshInterval: config.refreshInterval || 60000
  }
}

// Usage
import { createAnalyticsDashboard } from 'https://products.do/analytics-dashboard'

export const dashboard = createAnalyticsDashboard({
  usersQuery: 'SELECT COUNT(*) FROM users',
  growthQuery: 'SELECT DATE(created_at), COUNT(*) FROM users GROUP BY 1',
  activityQuery: 'SELECT * FROM events ORDER BY created_at DESC LIMIT 10'
})

Block Registries

Building blocks are organized in registries:

Registry	URL	Contents
Products	`products.do`	Product templates (SaaS, Marketplace, API, Data)
Sites	`sites.do`	Site templates (Landing, Docs, Blog)
Apps	`apps.do`	App templates (Dashboard, Admin, Analytics)
Functions	`functions.do`	Reusable functions (Auth, Payments, Email)
Agents	`agents.do`	AI agents (Sales, Support, Marketing)
Integrations	`integrations.do`	Third-party integrations (Stripe, SendGrid)
Templates	`templates.do`	Full startup templates

Browse available blocks at each registry or search across all via Startups.Studio.

Next Steps

Lifecycle - Understand startup lifecycle stages
Portfolio - Manage multiple startups
Vibecode - Generate compositions with AI
Business - Learn Business-as-Code fundamentals

Startup Composition

On this page