Product photography with AI model customisation

Introduction

Product photography is a tedious bottleneck for e-commerce teams. You photograph a product, wait for editing, then manually adjust backgrounds and lighting, then upload everything to your product management system. If you need to produce variations with different models or customisations, you're repeating this process multiple times.

The real problem isn't the photography itself; it's the customisation and coordination that comes after. You might need to show the same product worn by different models, displayed in different settings, or rendered in various colour variants. Each variation typically means a new photoshoot or expensive manual retouching. This is where AI model customisation becomes valuable. Rather than hiring multiple models or staging multiple shoots, you can generate consistent product visuals with different people and settings applied automatically.

This Alchemy workflow combines three tools to build a fully automated product photography pipeline. AI-Boost handles the initial image processing and quality checks, nsketch-AI generates model variations and customisations, and PickOrCraft selects the best results and prepares them for publishing. Everything happens without manual handoff; once you upload a product image and specify your customisations, the system delivers finished photos ready for your catalogue.

The Automated Workflow

Understanding the Data Flow

Before wiring everything together, picture the journey your image takes. A product photo enters the system (from Shopify, a webhook, or direct upload). AI-Boost processes it, passing metrics to the orchestration layer. nsketch-AI then applies customisations like model variations or background changes, generating multiple outputs. PickOrCraft evaluates these outputs based on your criteria, selects the winners, and pushes them to your final destination (your product database, DAM system, or S3 bucket).

The orchestration tool acts as the nervous system, triggering each step only when the previous one completes successfully, and routing data between services without anyone touching anything manually.

Choosing Your Orchestration Tool

For a beginner-friendly setup, I'd recommend n8n or Zapier. Both handle file transfers reliably, neither requires you to write much code, and both allow you to visualise the entire workflow as a diagram.

If you want to avoid monthly SaaS costs and can tolerate a steeper learning curve, Make (formerly Integromat) offers a generous free tier and better file handling for image workflows. Claude Code is useful if you need custom logic to analyse results or transform data mid-workflow, but it's not a full orchestration platform on its own; use it as a helper alongside one of the main three.

Setting Up the Workflow: A Practical Example

Let's build a concrete workflow. Assume you're an e-commerce company selling clothing, and you want to automatically generate product photos with different model variations and backgrounds.

Step 1: Receive the Trigger

Your workflow starts when someone uploads a product image to a folder in Google Drive or Dropbox, or submits a form with product details. In n8n, this looks like:

Copy
Trigger: Google Drive → File Created
Condition: Check file extension is .jpg or .png
Output: File ID, filename, folder path

In Zapier, you'd use the Google Drive trigger with similar conditions.

Step 2: Validate and Process with AI-Boost

AI-Boost's main purpose here is quality assurance. It checks that the image is suitable for further processing: adequate resolution (min 1200px width), proper lighting, no corruption. You'll call the AI-Boost API to analyse the image.

First, download the file from Google Drive and prepare it. In n8n, use the HTTP Request node:

Copy
GET https://www.googleapis.com/drive/v3/files/{fileId}?alt=media
Headers:
  Authorization: Bearer YOUR_GOOGLE_DRIVE_TOKEN
Output: Binary image data

Then send it to AI-Boost for analysis:

Copy
POST https://api.aiboost.example.com/v1/analyse
Headers:
  Authorization: Bearer YOUR_AIBOOST_API_KEY
  Content-Type: application/json
Body:
{
  "image_url": "https://your-cdn.com/temp-uploads/product-001.jpg",
  "check_type": "product_photography",
  "min_resolution": 1200,
  "quality_threshold": 0.75
}
Response:
{
  "status": "pass",
  "quality_score": 0.88,
  "resolution": 2400,
  "issues": [],
  "recommended_adjustments": []
}

Step 3: Define Customisations

Before nsketch-AI generates variations, you need to specify what customisations you want. Store these as configuration in your workflow. For example:

Copy{
  "product_id": "SHIRT-001",
  "variations": [
    {
      "variation_name": "model_tall_female",
      "model_type": "female",
      "model_height": "tall",
      "background": "studio_white",
      "lighting": "studio_3light"
    },
    {
      "variation_name": "model_athletic_male",
      "model_type": "male",
      "model_build": "athletic",
      "background": "lifestyle_outdoor",
      "lighting": "natural_sunlight"
    },
    {
      "variation_name": "flatlay",
      "background": "marble_table",
      "camera_angle": "flat",
      "no_model": true
    }
  ]
}

In your orchestration tool, you can hardcode this per product or pull it from a Google Sheet or database.

Step 4: Generate Variations with nsketch-AI

Now the original image and the customisation specs go to nsketch-AI. This is where the heavy lifting happens. nsketch-AI can map different models onto the original product, change backgrounds, and adjust lighting. Call the API once for each variation:

Copy
POST https://api.nsketch-ai.example.com/v2/customise
Headers:
  Authorization: Bearer YOUR_NSKETCH_API_KEY
  Content-Type: application/json
Body:
{
  "source_image_url": "https://your-cdn.com/uploads/product-001.jpg",
  "customisations": {
    "model_type": "female",
    "model_height": "tall",
    "background": "studio_white",
    "lighting": "studio_3light",
    "style_reference": null
  },
  "output_format": "jpg",
  "quality": "high",
  "webhook_url": "https://your-webhook-handler.com/nsketch-complete"
}
Response:
{
  "job_id": "nsketch-job-abc123xyz",
  "status": "queued",
  "estimated_time_seconds": 45
}

nsketch-AI works asynchronously. Rather than waiting, it sends a webhook when each variation is ready. Your orchestration tool should have a webhook listener waiting for:

Copy{
  "job_id": "nsketch-job-abc123xyz",
  "status": "complete",
  "output_urls": [
    "https://output.nsketch-ai.com/nsketch-job-abc123xyz/variation-1.jpg",
    "https://output.nsketch-ai.com/nsketch-job-abc123xyz/variation-2.jpg"
  ],
  "variations_generated": 3
}

In n8n, create a separate webhook node to catch these callbacks. In Zapier, use the Webhooks by Zapier trigger.

Step 5: Evaluate Results with PickOrCraft

You've now got three generated images (one for each customisation). PickOrCraft evaluates them based on your criteria: does the model look natural, is the background clean, does the product stand out? It scores each image and ranks them.

Copy
POST https://api.pickorcraft.example.com/v1/evaluate-batch
Headers:
  Authorization: Bearer YOUR_PICKORCRAFT_API_KEY
  Content-Type: application/json
Body:
{
  "images": [
    {
      "url": "https://output.nsketch-ai.com/nsketch-job-abc123xyz/variation-1.jpg",
      "label": "model_tall_female",
      "evaluation_criteria": [
        "model_realism",
        "background_quality",
        "product_visibility",
        "lighting_consistency"
      ]
    },
    {
      "url": "https://output.nsketch-ai.com/nsketch-job-abc123xyz/variation-2.jpg",
      "label": "model_athletic_male",
      "evaluation_criteria": [
        "model_realism",
        "background_quality",
        "product_visibility",
        "lighting_consistency"
      ]
    },
    {
      "url": "https://output.nsketch-ai.com/nsketch-job-abc123xyz/variation-3.jpg",
      "label": "flatlay",
      "evaluation_criteria": [
        "composition",
        "background_quality",
        "product_visibility",
        "lighting_consistency"
      ]
    }
  ],
  "min_passing_score": 0.70
}
Response:
{
  "evaluation_complete": true,
  "results": [
    {
      "label": "model_tall_female",
      "overall_score": 0.89,
      "criteria_scores": {
        "model_realism": 0.91,
        "background_quality": 0.87,
        "product_visibility": 0.88,
        "lighting_consistency": 0.89
      },
      "passed": true
    },
    {
      "label": "model_athletic_male",
      "overall_score": 0.75,
      "criteria_scores": {
        "model_realism": 0.72,
        "background_quality": 0.78,
        "product_visibility": 0.76,
        "lighting_consistency": 0.76
      },
      "passed": true
    },
    {
      "label": "flatlay",
      "overall_score": 0.68,
      "criteria_scores": {
        "composition": 0.65,
        "background_quality": 0.70,
        "product_visibility": 0.72,
        "lighting_consistency": 0.67
      },
      "passed": false
    }
  ]
}

Step 6: Upload Passing Results

Only images that pass PickOrCraft's evaluation move forward. In this example, two images passed. Now upload them to your product database or DAM system. If you use Shopify, call the Shopify API:

Copy
POST https://your-shop.myshopify.com/admin/api/2024-01/products/{product_id}/images.json
Headers:
  Authorization: Bearer YOUR_SHOPIFY_API_TOKEN
  Content-Type: application/json
Body:
{
  "image": {
    "attachment": "base64-encoded-image-data",
    "alt": "Product worn by tall female model on white studio background",
    "position": 1
  }
}
Response:
{
  "image": {
    "id": 12345678,
    "product_id": 67890,
    "position": 1,
    "created_at": "2024-01-15T10:30:00Z",
    "src": "https://cdn.shopify.com/..."
  }
}

For a generic S3 bucket or Google Cloud Storage, download the image and upload:

Copy
PUT https://your-bucket.s3.amazonaws.com/products/SHIRT-001/model-tall-female.jpg
Headers:
  Authorization: AWS4-HMAC-SHA256 ...
  Content-Type: image/jpeg
Body: Binary image data

Step 7: Log and Notify

Finally, log the results back to a spreadsheet or notification system so you know what succeeded:

Copy
POST https://sheets.googleapis.com/v4/spreadsheets/{spreadsheet_id}/values/ProcessLog!A1:append
Headers:
  Authorization: Bearer YOUR_GOOGLE_SHEETS_TOKEN
  Content-Type: application/json
Body:
{
  "values": [
    [
      "SHIRT-001",
      "2024-01-15",
      "3 variations generated",
      "2 passed evaluation",
      "2 uploaded to Shopify",
      "Success"
    ]
  ]
}

The Manual Alternative

If you want more control over which variations are actually used, insert a manual approval step before uploading. In n8n or Zapier, this means pausing the workflow and sending you a notification with a preview of all generated images, asking which ones to publish.

PickOrCraft's evaluation is excellent, but it's algorithmic; you might disagree with its scoring if, say, you prefer a certain model variant or background aesthetic. A human review checkpoint costs time but gives you veto power.

To implement this, have your orchestration tool send you an email or Slack message with all the results and their scores, then wait for you to respond with approvals. Use a form submission (Typeform, Google Forms) or a simple "Yes/No" button in Zapier's notification to collect your decision. Only proceed to upload once you've approved.

This approach reduces full automation but keeps the workflow 90% hands-off; instead of retouching images, you're just clicking a couple of buttons.

Pro Tips

Rate Limiting and Concurrent Requests

nsketch-AI typically allows 5-10 simultaneous customisation jobs depending on your plan. If you're generating 20+ product variations, don't blast all requests at once. In your orchestration tool, add a delay between requests or use a loop with a built-in pause (2-3 seconds between API calls). This prevents API throttling and keeps costs predictable.

Copy
For each variation in variations_list:
  POST to nsketch-AI
  Wait 2 seconds
  Continue

Error Handling and Retries

Image processing can fail for reasons outside your control: temporary API downtime, corrupt image data, or network hiccups. Configure automatic retries with exponential backoff. In n8n:

Copy
HTTP Request node
  → On Error: Wait 5 seconds, retry once
  → On Error again: Wait 10 seconds, retry once more
  → On Error still: Send alert to Slack, skip this image

Cost Optimisation

Each tool charges based on usage. nsketch-AI's biggest cost is the number of customisations generated; PickOrCraft charges per image evaluated. To reduce spend:

• Batch similar products together so you generate variations once and reuse results.

• Set PickOrCraft's minimum passing score appropriately; too high and you'll regenerate many times (expensive), too low and you'll publish poor results (bad for business).

• Cache successful configurations. If you generate the same variation twice, reuse the first result rather than calling nsketch-AI again.

Webhook Reliability

nsketch-AI and other async APIs send webhooks when processing completes. Networks are unreliable; sometimes webhooks fail to arrive. Build a fallback polling mechanism: if you don't receive a webhook within the estimated time, your orchestration tool should call nsketch-AI's status endpoint to check if the job finished.

Copy
Start job at 10:00 AM
Expected completion: 10:00:45 AM
No webhook received by 10:02 AM?
  → Poll status: GET https://api.nsketch-ai.example.com/v1/jobs/nsketch-job-abc123xyz
  → If complete, retrieve results manually
  → If failed, retry the customisation

Monitor Quality Metrics

Over time, keep track of which customisations pass PickOrCraft's evaluation. If "flatlay" consistently fails, adjust your photography setup (better lighting, cleaner background) or lower the evaluation threshold specifically for flatlay shots. Use the log data from Step 7 to identify patterns and improve your input quality.

Cost Breakdown

This cost structure assumes medium volume. If you're processing 100+ products monthly, negotiate volume discounts with nsketch-AI and PickOrCraft. If you're processing fewer than 10 products/month, the per-product cost is higher due to fixed tool costs; consider manual processing instead.