Monetization Strategies

Learn how to monetize your Services-as-Software with flexible pricing models and built-in billing.

Pricing Models

graph LR Service[Your Service] Service --> Sub[Subscription Model] Service --> Usage[Usage-Based Model] Service --> Hybrid[Hybrid Model] Service --> Outcome[Outcome-Based Model] Sub --> SubEx[Monthly/Annual Plans] Usage --> UsageEx[Pay per API Call] Hybrid --> HybridEx[Base + Overage] Outcome --> OutcomeEx[Pay per Result]

The .do platform supports multiple pricing models:

Subscription Model

Charge recurring fees:

export default service({
  name: 'Email Marketing Service',

  pricing: {
    model: 'subscription',
    plans: [
      {
        name: 'Starter',
        price: 29,
        interval: 'month',
        features: ['1,000 contacts', '10,000 emails/month', 'Basic templates', 'Email support'],
        limits: {
          contacts: 1000,
          emailsPerMonth: 10000,
        },
      },
      {
        name: 'Professional',
        price: 99,
        interval: 'month',
        features: ['10,000 contacts', '100,000 emails/month', 'Advanced templates', 'A/B testing', 'Priority support'],
        limits: {
          contacts: 10000,
          emailsPerMonth: 100000,
        },
      },
      {
        name: 'Enterprise',
        price: 299,
        interval: 'month',
        features: ['Unlimited contacts', 'Unlimited emails', 'Custom templates', 'Advanced analytics', 'Dedicated support', 'Custom integrations'],
        limits: {
          contacts: -1, // Unlimited
          emailsPerMonth: -1,
        },
      },
    ],
  },
})

Usage-Based Model

Charge based on consumption:

pricing: {
  model: 'usage',
  metric: 'api_calls',
  tiers: [
    {
      up_to: 1000,
      price_per_unit: 0.10,
    },
    {
      up_to: 10000,
      price_per_unit: 0.08,
    },
    {
      up_to: 100000,
      price_per_unit: 0.06,
    },
    {
      above: 100000,
      price_per_unit: 0.05,
    },
  ],
}

Example pricing:

0-1,000 calls: $0.10 per call
1,001-10,000 calls: $0.08 per call
10,001-100,000 calls: $0.06 per call
100,000+ calls: $0.05 per call

Hybrid Model

Combine subscription + usage:

pricing: {
  model: 'hybrid',
  subscription: {
    base: 49,
    interval: 'month',
    includes: 1000,  // Included units
  },
  overage: {
    metric: 'api_calls',
    price_per_unit: 0.05,
  },
}

Example:

Base: $49/month includes 1,000 API calls
Overage: $0.05 per additional call

Feature-Based Model

Charge for specific features:

pricing: {
  model: 'feature-based',
  features: [
    {
      name: 'Basic',
      price: 0,
      features: ['core_functionality'],
    },
    {
      name: 'AI Analytics',
      price: 29,
      features: ['core_functionality', 'ai_analytics'],
    },
    {
      name: 'Advanced AI',
      price: 99,
      features: ['core_functionality', 'ai_analytics', 'advanced_ai', 'custom_models'],
    },
  ],
}

Outcome-Based Model

Charge based on results:

pricing: {
  model: 'outcome-based',
  outcomes: [
    {
      metric: 'leads_generated',
      price_per_outcome: 5.00,
      minimum: 10,
    },
    {
      metric: 'sales_closed',
      price_per_outcome: 50.00,
      minimum: 1,
    },
  ],
}

Example:

$5 per lead generated
$50 per sale closed

Revenue Strategies

flowchart TD Visitor[Visitor] --> Free[Free Tier] Free --> UsesFree[Uses Free Features] UsesFree --> Limit{Hit Limits?} Limit -->|No| Continue[Continue Free] Limit -->|Yes| Upgrade[Upgrade Prompt] Upgrade --> Trial[Start Trial] Trial --> Convert{Convert?} Convert -->|Yes| Paid[Paid Customer] Convert -->|No| Downgrade[Back to Free] Paid --> Upsell{More Usage?} Upsell -->|Yes| Premium[Premium Tier] Upsell -->|No| Retain[Stay on Plan]

Freemium

Offer free tier to attract users:

pricing: {
  model: 'subscription',
  plans: [
    {
      name: 'Free',
      price: 0,
      features: ['Basic features', '100 requests/month'],
      limits: {
        requestsPerMonth: 100,
        features: ['basic'],
      },
    },
    {
      name: 'Pro',
      price: 49,
      features: ['All features', '10,000 requests/month'],
      limits: {
        requestsPerMonth: 10000,
        features: ['basic', 'advanced'],
      },
    },
  ],
}

Free Trial

Offer trial period:

pricing: {
  model: 'subscription',
  trial: {
    duration: 14,  // days
    includesPlan: 'Professional',
  },
  plans: [
    {
      name: 'Professional',
      price: 99,
      interval: 'month',
    },
  ],
}

Pay-As-You-Grow

Scale pricing with usage:

pricing: {
  model: 'usage',
  metric: 'monthly_active_users',
  tiers: [
    { up_to: 100, price_per_unit: 1.00 },
    { up_to: 1000, price_per_unit: 0.75 },
    { up_to: 10000, price_per_unit: 0.50 },
    { above: 10000, price_per_unit: 0.25 },
  ],
}

Volume Discounts

Incentivize larger purchases:

pricing: {
  model: 'subscription',
  plans: [
    {
      name: 'Professional',
      price: 99,
      interval: 'month',
    },
    {
      name: 'Professional Annual',
      price: 990,  // $82.50/month (17% discount)
      interval: 'year',
      discount: {
        type: 'percentage',
        value: 17,
      },
    },
  ],
}

Usage Tracking

Track usage for billing:

// Track API calls
on: {
  '$.API.request': async (event) => {
    // Process request
    const result = await processRequest(event.data)

    // Record usage
    await $.usage.record({
      customerId: event.data.customerId,
      metric: 'api_calls',
      quantity: 1,
      timestamp: new Date(),
    })

    return result
  },
}

// Track complex metrics
on: {
  '$.Report.generated': async (event) => {
    // Record based on report size
    await $.usage.record({
      customerId: event.data.customerId,
      metric: 'data_processed',
      quantity: event.data.rowCount,
      metadata: {
        reportId: event.data.id,
        reportType: event.data.type,
      },
    })
  },
}

Query usage:

// Get customer usage
const usage = await $.usage.query({
  customerId: 'cust_123',
  metric: 'api_calls',
  period: 'current_month',
})

console.log(usage)
// {
//   metric: 'api_calls',
//   quantity: 8543,
//   period: '2025-10',
//   cost: 427.15
// }

Billing Integration

Automatic Billing

Billing is handled automatically:

pricing: {
  model: 'subscription',
  billing: {
    provider: 'stripe',
    interval: 'month',
    invoiceDayOfMonth: 1,
    paymentTerms: 'net-15',
  },
  plans: [/* ... */],
}

Invoice Generation

Invoices are generated automatically:

on: {
  '$.Billing.period-end': async (event) => {
    const customer = event.data.customer
    const usage = event.data.usage

    // Calculate charges
    const charges = calculateCharges(usage)

    // Generate invoice
    const invoice = await $.Invoice.create({
      customer: customer.id,
      items: charges,
      dueDate: new Date(Date.now() + 15 * 24 * 60 * 60 * 1000),
    })

    // Send to customer
    await $.Email.send({
      to: customer.email,
      template: 'invoice',
      data: { invoice },
    })
  },
}

Payment Processing

Process payments automatically:

on: {
  '$.Invoice.created': async (event) => {
    const invoice = event.data

    // Attempt payment
    try {
      const payment = await $.Payment.charge({
        customer: invoice.customerId,
        amount: invoice.total,
        description: `Invoice ${invoice.number}`,
      })

      // Mark invoice as paid
      await invoice.update({
        status: '$.Paid',
        paidAt: new Date(),
        paymentId: payment.id,
      })
    } catch (error) {
      // Handle payment failure
      await handlePaymentFailure(invoice, error)
    }
  },
}

Revenue Optimization

Price Testing

A/B test pricing:

pricing: {
  model: 'subscription',
  experiments: [
    {
      name: 'pricing-test-v1',
      variants: [
        {
          name: 'control',
          weight: 50,
          plans: [
            { name: 'Pro', price: 99 },
          ],
        },
        {
          name: 'higher-price',
          weight: 50,
          plans: [
            { name: 'Pro', price: 129 },
          ],
        },
      ],
    },
  ],
}

Usage Alerts

Alert customers about usage:

on: {
  '$.Usage.threshold-reached': async (event) => {
    const customer = event.data.customer
    const usage = event.data.usage

    // Send alert at 80% of limit
    if (usage.percentOfLimit >= 80) {
      await $.Email.send({
        to: customer.email,
        template: 'usage-alert',
        data: {
          usage: usage.current,
          limit: usage.limit,
          percent: usage.percentOfLimit,
        },
      })
    }
  },
}

Upgrade Prompts

Encourage upgrades:

on: {
  '$.Usage.limit-exceeded': async (event) => {
    const customer = event.data.customer

    // Suggest upgrade
    await $.Email.send({
      to: customer.email,
      template: 'upgrade-suggestion',
      data: {
        currentPlan: customer.plan,
        suggestedPlan: 'Professional',
        benefits: [
          'Higher limits',
          'Advanced features',
          'Priority support',
        ],
      },
    })
  },
}

Churn Prevention

Reduce cancellations:

on: {
  '$.Subscription.cancellation-requested': async (event) => {
    const customer = event.data.customer

    // Offer discount to retain
    await $.Email.send({
      to: customer.email,
      template: 'retention-offer',
      data: {
        discount: 25,  // 25% off for 3 months
        duration: 3,
      },
    })

    // Delay cancellation
    await event.data.update({
      status: '$.PendingCancellation',
      cancellationDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
    })
  },
}

Revenue Analytics

MRR Tracking

Track Monthly Recurring Revenue:

// Query MRR
const mrr = await $.Metric.query({
  metric: 'mrr',
  service: 'my-service',
  timeRange: 'last_12_months',
})

console.log(mrr)
// {
//   current: 15420,
//   growth: 12.5,  // %
//   trend: 'up'
// }

Customer Lifetime Value

Calculate LTV:

const ltv = await $.Customer.ltv({
  customerId: 'cust_123',
})

console.log(ltv)
// {
//   totalRevenue: 2340,
//   avgMonthlyRevenue: 195,
//   tenureMonths: 12,
//   projectedLtv: 4680,
// }

Revenue by Plan

Analyze plan performance:

const revenue = await $.Revenue.byPlan({
  service: 'my-service',
  timeRange: 'last_month',
})

console.log(revenue)
// [
//   { plan: 'Starter', revenue: 2900, customers: 100 },
//   { plan: 'Professional', revenue: 9900, customers: 100 },
//   { plan: 'Enterprise', revenue: 8970, customers: 30 }
// ]

Pricing Strategy Examples

SaaS Model

pricing: {
  model: 'subscription',
  plans: [
    { name: 'Starter', price: 29, users: 5 },
    { name: 'Team', price: 99, users: 20 },
    { name: 'Business', price: 299, users: 100 },
  ],
}

API Service Model

pricing: {
  model: 'usage',
  metric: 'api_requests',
  tiers: [
    { up_to: 10000, price_per_unit: 0.01 },
    { up_to: 100000, price_per_unit: 0.008 },
    { above: 100000, price_per_unit: 0.006 },
  ],
}

AI Service Model

pricing: {
  model: 'hybrid',
  subscription: {
    base: 99,
    includes: 1000,  // AI generations
  },
  overage: {
    metric: 'ai_generations',
    price_per_unit: 0.10,
  },
}

Consulting Service Model

pricing: {
  model: 'outcome-based',
  outcomes: [
    { metric: 'consultation_hours', price_per_outcome: 200 },
    { metric: 'reports_delivered', price_per_outcome: 500 },
    { metric: 'implementations', price_per_outcome: 2000 },
  ],
}

Best Practices

Keep Pricing Simple

Avoid confusing pricing structures:

// Good: Clear and simple
pricing: {
  model: 'subscription',
  plans: [
    { name: 'Basic', price: 29 },
    { name: 'Pro', price: 99 },
  ],
}

// Bad: Too complex
pricing: {
  model: 'complex',
  base: 29,
  addons: [
    { name: 'Feature A', price: 5 },
    { name: 'Feature B', price: 10 },
    { name: 'Feature C', price: 15 },
  ],
  tiers: [/* ... */],
  modifiers: [/* ... */],
}

Transparent Pricing

Show customers what they'll pay:

// Calculate before charging
const estimate = await $.Billing.estimate({
  customerId: 'cust_123',
  plan: 'Professional',
})

console.log(estimate)
// {
//   base: 99,
//   tax: 8.91,
//   total: 107.91,
//   nextBillingDate: '2025-11-24'
// }

Fair Usage Limits

Set reasonable limits:

pricing: {
  plans: [
    {
      name: 'Starter',
      price: 29,
      limits: {
        requestsPerDay: 1000,
        requestsPerMonth: 30000,
      },
    },
  ],
}

Next Steps

Examples - See monetization examples
Pricing & Billing - Detailed billing integration
Best Practices - Pricing best practices

Monetization Strategies

On this page