How I Built a Photo Editing SaaS with Zero ML Code (Just 1 API)

I wanted to build a photo editing SaaS. Background removal, face enhancement, anime filters, OCR, content moderation. Each feature normally requires its own ML model, its own GPU, its own API subscription.

Instead, I built the whole thing with one API, one Lambda function, and zero ML code. Twelve AI features, $15/month infrastructure cost, 16x margin on every request.

The 12 Features

Every feature is a single POST request to the same API host. Same key, same auth, same response format.

All endpoints are on ai-all-in-one.p.rapidapi.com. One host, one key, one subscription.

Architecture

No GPU on your side. No ML models. No Docker containers with TensorFlow. The Lambda function is a proxy that checks credits and forwards the request.

The Backend

The entire Lambda handler in one file:

import json
import boto3
import requests

API_HOST = "ai-all-in-one.p.rapidapi.com"
API_KEY = "YOUR_RAPIDAPI_KEY"  # store in env vars / Secrets Manager
HEADERS = {"x-rapidapi-key": API_KEY, "x-rapidapi-host": API_HOST}

# Credits cost per action
COSTS = {
    "remove-bg": (1, "/v1/remove-background"),
    "blur-bg": (1, "/v1/blur-background"),
    "enhance-face": (1, "/v1/enhance-face"),
    "cartoonize": (1, "/v1/cartoonize"),
    "colorize": (1, "/v1/colorize-photo"),
    "portrait": (1, "/v1/photo-to-portrait"),
    "face-swap": (1, "/v1/swap-face"),
    "ocr": (2, "/v1/ocr"),
    "detect-objects": (2, "/v1/objects-detection"),
    "face-analysis": (2, "/v1/faceanalysis"),
    "nsfw-check": (2, "/v1/nsfw-detect"),
}

dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table("user_credits")


def handler(event, context):
    user_id = event["requestContext"]["authorizer"]["user_id"]
    action = event["queryStringParameters"]["action"]

    if action not in COSTS:
        return {"statusCode": 400, "body": json.dumps({"error": "Unknown action"})}

    cost, endpoint = COSTS[action]

    # Check credits
    user = table.get_item(Key={"user_id": user_id}).get("Item", {})
    credits = user.get("credits", 0)
    if credits < cost:
        return {"statusCode": 402, "body": json.dumps({"error": "Not enough credits"})}

    # Call AI API
    body = json.loads(event["body"])
    resp = requests.post(
        f"https://{API_HOST}{endpoint}",
        headers={**HEADERS, "Content-Type": "application/json"},
        json=body,
    )

    # Decrement credits
    table.update_item(
        Key={"user_id": user_id},
        UpdateExpression="SET credits = credits - :c",
        ExpressionAttributeValues={":c": cost},
    )

    return {"statusCode": 200, "body": resp.text}

That is the entire backend. Every AI feature goes through the same function. The action parameter selects the endpoint, the credits system handles billing.

Credits System

Each user gets a credits balance in DynamoDB. Simple key-value:

{
  "user_id": "usr_abc123",
  "credits": 450,
  "plan": "pro"
}

When a user calls an action, the Lambda checks their balance, calls the API, and decrements. Image features cost 1 credit. Analysis features (OCR, object detection, face analysis) cost 2.

For signups, insert a row with 10 free credits. For paid plans, a Stripe webhook increments the balance monthly.

The Money Math

This is where it gets interesting.

Your cost per request

Your revenue per request

If you charge your users $0.02 per credit (or $9.99/month for 500 credits):

Monthly projection

Ten paying users and you are profitable. One hundred and you are making $944/month from a Lambda function and an API subscription.

How to Charge Your Users

The credits model makes pricing simple. Sell credits at $0.02 each ($9.99/month for 500 credits), give 10 free per day to attract signups. Every feature maps to a credit cost, so you never need to change your pricing when you add new features.

Why This Works

• One integration: 12 features from 1 API means 1 set of docs, 1 SDK, 1 billing dashboard
• No ML ops: no models to download, update, or host. The API handles GPU inference
• Scales to zero: Lambda + DynamoDB on-demand means you pay nothing when nobody is using it
• Ship fast: the backend is ~50 lines of Python. The hard part is the frontend, not the AI