"Building AI SaaS on a Budget: From Zero to Revenue with Minimal Spend"

┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│   Frontend   │────▶│   Backend    │────▶│  AI API      │
│   (React/    │     │   (Node.js/  │     │  (Crazyrouter│
│    Next.js)  │◀────│    Python)   │◀────│   /v1)       │
└──────────────┘     └──────┬───────┘     └──────────────┘
                            │
                     ┌──────▼───────┐
                     │   Database   │
                     │  (Postgres/  │
                     │   SQLite)    │
                     └──────────────┘

from openai import OpenAI

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

# Cost per 1M tokens (input/output)
MODEL_COSTS = {
    "gpt-4.1-nano":    {"input": 0.10, "output": 0.40},    # Simple tasks
    "gpt-4.1-mini":    {"input": 0.40, "output": 1.60},    # Standard tasks
    "gpt-4.1":         {"input": 2.00, "output": 8.00},    # Complex tasks
    "deepseek-v3":     {"input": 0.27, "output": 1.10},    # Great value
}

def get_model_for_task(task_type):
    """Select the cheapest adequate model for each task."""
    routing = {
        "classification": "gpt-4.1-nano",     # $0.10/M — simple
        "summarization": "gpt-4.1-mini",      # $0.40/M — medium
        "extraction": "gpt-4.1-mini",         # $0.40/M — medium
        "generation": "gpt-4.1",              # $2.00/M — needs quality
        "code": "gpt-4.1",                    # $2.00/M — needs precision
        "chat": "deepseek-v3",                # $0.27/M — great for chat
    }
    return routing.get(task_type, "gpt-4.1-mini")

import hashlib
import json
from functools import lru_cache

# Simple in-memory cache (use Redis in production)
response_cache = {}

def cached_completion(messages, model, temperature=0):
    """Cache deterministic API calls."""
    # Only cache when temperature=0 (deterministic)
    if temperature > 0:
        return client.chat.completions.create(
            model=model, messages=messages, temperature=temperature
        )
    
    # Create cache key from messages + model
    cache_key = hashlib.md5(
        json.dumps({"messages": messages, "model": model}).encode()
    ).hexdigest()
    
    if cache_key in response_cache:
        return response_cache[cache_key]
    
    response = client.chat.completions.create(
        model=model, messages=messages, temperature=0
    )
    
    response_cache[cache_key] = response
    return response

# ❌ Verbose system prompt (150 tokens)
system_bad = """You are an AI assistant that helps users with their questions. 
You should always be helpful, harmless, and honest. When answering questions, 
please provide detailed and comprehensive responses that cover all aspects of 
the topic. Make sure to be accurate and cite sources when possible. If you 
don't know something, please say so rather than making things up."""

# ✅ Concise system prompt (30 tokens)
system_good = """Helpful AI assistant. Be accurate and concise. 
Say "I don't know" when uncertain."""

# Savings: 120 tokens per request × 10,000 requests/day = 1.2M tokens/day saved
# At $2/M tokens = $2.40/day = $72/month saved just from system prompt

async def batch_process(items, model="gpt-4.1-mini"):
    """Process multiple items efficiently."""
    # Combine multiple items into fewer API calls
    batch_size = 10
    results = []
    
    for i in range(0, len(items), batch_size):
        batch = items[i:i + batch_size]
        combined_prompt = "Process each item below. Return JSON array of results.\n\n"
        for j, item in enumerate(batch):
            combined_prompt += f"Item {j+1}: {item}\n"
        
        response = client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": combined_prompt}],
            response_format={"type": "json_object"}
        )
        
        batch_results = json.loads(response.choices[0].message.content)
        results.extend(batch_results.get("results", []))
    
    return results

Your cost per request:
  - AI API: ~$0.002 (GPT-4.1-mini, avg 1K tokens)
  - Infrastructure: ~$0.0001
  - Total: ~$0.0021

Your pricing per request:
  - Free tier: $0 (limited to 50/day)
  - Pro tier: ~$0.01 per request ($20/mo for 2000 requests)
  
Gross margin: ($0.01 - $0.0021) / $0.01 = 79%

Free Plan:        $0/mo  — 50 requests/day, basic models
Starter Plan:    $19/mo  — 500 requests/day, all models
Pro Plan:        $49/mo  — 2000 requests/day, priority, API access
Enterprise:    Custom    — Unlimited, SLA, dedicated support