"Building AI SaaS on a Budget 2026: Under $100/Month Stack"

# Don't use Claude Opus for everything — it's expensive
# Route tasks to the right model

MODEL_ROUTING = {
    # Cheap tasks: use cheap models ($0.15-0.30/1M input)
    "text_classification": "gpt-5-mini",
    "sentiment_analysis": "gpt-5-mini", 
    "keyword_extraction": "gemini-2.5-flash-lite",
    "simple_qa": "claude-haiku-4-5",
    
    # Medium tasks: use balanced models ($1-3/1M input)
    "content_generation": "claude-sonnet-4-5",
    "summarization": "claude-sonnet-4-5",
    "code_explanation": "deepseek-v3.2",  # Very cheap, surprisingly good
    
    # Complex tasks only: use powerful models ($10-15/1M input)
    "complex_reasoning": "claude-opus-4-6",
    "code_review": "claude-opus-4-6",
    "legal_analysis": "gpt-5-2",
}

def route_to_model(task_type: str) -> str:
    return MODEL_ROUTING.get(task_type, "claude-sonnet-4-5")  # Safe default

from openai import OpenAI
from typing import Optional

client = OpenAI(
    api_key="your-crazyrouter-key",
    base_url="https://crazyrouter.com/v1"
)

class BudgetAwareAI:
    """AI client with automatic cost controls."""
    
    def __init__(self, monthly_budget_usd: float = 30.0):
        self.monthly_budget = monthly_budget_usd
        self.spent_this_month = 0.0
        
        # Approximate cost per 1M tokens (in USD)
        self.model_costs = {
            "gpt-5-mini": {"input": 0.15, "output": 0.6},
            "gemini-2.5-flash-lite": {"input": 0.1, "output": 0.4},
            "deepseek-v3.2": {"input": 0.27, "output": 1.1},
            "claude-haiku-4-5": {"input": 0.8, "output": 4.0},
            "claude-sonnet-4-5": {"input": 3.0, "output": 15.0},
            "claude-opus-4-6": {"input": 15.0, "output": 75.0},
        }
    
    def estimate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
        costs = self.model_costs.get(model, {"input": 5.0, "output": 15.0})
        return (input_tokens * costs["input"] + output_tokens * costs["output"]) / 1_000_000
    
    def complete(
        self,
        messages: list,
        model: str = "claude-sonnet-4-5",
        max_tokens: int = 1024,
        fallback_model: Optional[str] = "gpt-5-mini"
    ) -> str:
        # Check budget
        budget_remaining = self.monthly_budget - self.spent_this_month
        estimated_cost = self.estimate_cost(model, 2000, max_tokens)  # rough estimate
        
        if budget_remaining < estimated_cost and fallback_model:
            print(f"Budget low, falling back to {fallback_model}")
            model = fallback_model
        
        response = client.chat.completions.create(
            model=model,
            messages=messages,
            max_tokens=max_tokens
        )
        
        # Track actual cost
        usage = response.usage
        actual_cost = self.estimate_cost(
            model, usage.prompt_tokens, usage.completion_tokens
        )
        self.spent_this_month += actual_cost
        
        return response.choices[0].message.content

# Usage
ai = BudgetAwareAI(monthly_budget_usd=30.0)

result = ai.complete(
    messages=[{"role": "user", "content": "Summarize this article: ..."}],
    model="claude-sonnet-4-5"
)

User Request
    ↓
Vercel Edge Function (free tier: 100K requests/day)
    ↓
Rate Limiting (Upstash Redis — free tier: 10K requests/day)
    ↓  
Crazyrouter AI API (pay per use)
    ↓
Supabase DB (free tier: 500MB)
    ↓
Response to User

// pages/api/generate-post.ts (Next.js)
import { OpenAI } from 'openai';
import { createClient } from '@supabase/supabase-js';
import { Ratelimit } from '@upstash/ratelimit';
import { Redis } from '@upstash/redis';

const client = new OpenAI({
  apiKey: process.env.CRAZYROUTER_API_KEY!,
  baseURL: 'https://crazyrouter.com/v1',
});

const supabase = createClient(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_KEY!
);

const ratelimit = new Ratelimit({
  redis: Redis.fromEnv(),
  limiter: Ratelimit.slidingWindow(10, '1 h'), // 10 posts/hour per user
});

export default async function handler(req, res) {
  const { userId, topic, tone, wordCount } = req.body;
  
  // Rate limiting (protect against abuse)
  const { success } = await ratelimit.limit(userId);
  if (!success) {
    return res.status(429).json({ error: 'Rate limit exceeded' });
  }
  
  // Check user's monthly quota
  const { data: user } = await supabase
    .from('users')
    .select('posts_generated, plan')
    .eq('id', userId)
    .single();
  
  const limits = { free: 5, pro: 100, business: 1000 };
  if (user.posts_generated >= limits[user.plan]) {
    return res.status(402).json({ error: 'Monthly limit reached — upgrade to continue' });
  }
  
  // Select model based on plan (cost optimization)
  const model = user.plan === 'business' ? 'claude-opus-4-6' :
                user.plan === 'pro' ? 'claude-sonnet-4-5' : 
                'gpt-5-mini';  // Free users get cheaper model
  
  try {
    const stream = await client.chat.completions.create({
      model,
      messages: [
        {
          role: 'system',
          content: `You are an expert content writer. Write in a ${tone} tone.`
        },
        {
          role: 'user',
          content: `Write a ${wordCount}-word blog post about: ${topic}`
        }
      ],
      stream: true,
      max_tokens: Math.ceil(wordCount * 1.5),
    });
    
    res.setHeader('Content-Type', 'text/event-stream');
    
    let fullContent = '';
    for await (const chunk of stream) {
      const delta = chunk.choices[0]?.delta?.content || '';
      fullContent += delta;
      res.write(`data: ${JSON.stringify({ content: delta })}\n\n`);
    }
    
    // Track usage
    await supabase
      .from('users')
      .update({ posts_generated: user.posts_generated + 1 })
      .eq('id', userId);
    
    // Save generated post
    await supabase.from('posts').insert({
      user_id: userId,
      topic,
      content: fullContent,
      model_used: model,
    });
    
    res.write('data: [DONE]\n\n');
    res.end();
    
  } catch (error) {
    return res.status(500).json({ error: 'Generation failed' });
  }
}

Free: 5 AI generations/month → Show the value
Pro ($19/month): 100 generations → Main revenue
Business ($99/month): 1,000 generations + API access

Break-even analysis:
- API costs at Pro tier (100 gen × ~500 tokens avg): ~$0.75/user
- Infrastructure per user (Vercel, Supabase): ~$0.30/user  
- Total cost: ~$1.05/user/month
- Revenue: $19/user/month
- Margin: ~94% at scale

def generate_with_limits(
    prompt: str,
    plan: str,
    max_tokens_by_plan: dict = {
        "free": 500,
        "pro": 2000,
        "business": 8000
    }
) -> str:
    """Apply output limits based on user's plan."""
    
    max_tokens = max_tokens_by_plan.get(plan, 500)
    model = "gpt-5-mini" if plan == "free" else "claude-sonnet-4-5"
    
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=max_tokens  # Hard limit — protects your costs
    )
    
    return response.choices[0].message.content

import json
from datetime import datetime

class CostTracker:
    def __init__(self, db_client):
        self.db = db_client
    
    async def log_usage(
        self, 
        user_id: str, 
        model: str,
        input_tokens: int,
        output_tokens: int
    ):
        # Model pricing (approximate)
        prices = {
            "gpt-5-mini": (0.15, 0.60),
            "claude-sonnet-4-5": (3.0, 15.0),
            "claude-opus-4-6": (15.0, 75.0),
        }
        
        inp, out = prices.get(model, (3.0, 15.0))
        cost = (input_tokens * inp + output_tokens * out) / 1_000_000
        
        await self.db.table("usage_logs").insert({
            "user_id": user_id,
            "model": model,
            "input_tokens": input_tokens,
            "output_tokens": output_tokens,
            "cost_usd": cost,
            "created_at": datetime.utcnow().isoformat()
        })
        
        # Alert if daily spend exceeds threshold
        daily_spend = await self.get_daily_spend()
        if daily_spend > 5.0:  # $5/day alert
            await self.send_alert(f"Daily AI spend: ${daily_spend:.2f}")