Building an AI System That Generates UGC Ads in Minutes (Multi-Model Orchestration Explained)

Creating ad creatives is still one of the slowest parts of growth.

Even today, the workflow looks like this:

• Find UGC creators


• Ship products


• Wait for content


• Edit and publish

This takes days (sometimes weeks).

We wanted to change that.

So we built a system that generates UGC-style video ads in under a minute using multiple AI models working together.

This post breaks down how we built it — from architecture to attribution fixes.

The Problem We Were Solving

We saw three major bottlenecks:

1. Creative Production Doesn’t Scale

Every new ad required a full production cycle.

This limits testing and slows down iteration.

2. AI Tools Are Fragmented

Most tools solve one part:

• Image generation


• Video generation


• Script generation

But not the entire pipeline.

3. Attribution Was Broken

We found:

• Duplicate install events


• Conflicting SDK signals


• Inflated metrics

Which made optimization unreliable.

System Overview

We didn’t build “an AI feature.”

We built a multi-model AI pipeline.

Core Components:

• Scenario API → Generates product visuals & variations


• Creatify API → Converts assets into video ads


• Custom Orchestration Layer → Manages flow, timing, and output

The Pipeline (Step-by-Step)

Here’s what happens when a user generates an ad:

1. User uploads a product image


2. Selects an AI actor


3. Scenario API generates visual assets


4. Creatify API renders video


5. Orchestration layer combines everything


6. Final ad is delivered

All of this happens in under a minute.

The Hard Part: Orchestration

The real challenge wasn’t calling APIs.

It was managing:

1. Async Processing

Each AI model responds at different times.

We had to design a system that:

• Waits intelligently


• Handles failures gracefully


• Keeps latency low

2. Output Consistency

Different models → different outputs.

We needed:

• Consistent visuals


• Cohesive storytelling


• Usable final ads

This required normalization and validation layers.

3. Speed Constraints

Target: < 60 seconds generation time

This meant:

• Parallel processing where possible


• Efficient retries


• Minimal blocking operations

Fixing Attribution (Critical Layer)

While building the creative engine, we discovered a bigger issue:

The data layer was broken.

Issues:

• Meta SDK + AppsFlyer conflicts


• Duplicate events


• Incorrect install tracking

Solution:

We rebuilt the attribution system:

• Set AppsFlyer as the single source of truth


• Removed conflicting signals


• Fixed event mapping:
  `- start_trial


• purchase`


• Enabled proper postbacks

Result:

• Clean tracking


• Accurate reporting


• Better campaign optimization

Product Layer: Hiding Complexity

Even with all this complexity, the product had to feel simple.

UX Principles:

• Minimal steps


• Fast feedback (instant previews)


• No technical configuration

The goal:

Hide complexity. Deliver power.

Results

• UGC ads generated in minutes


• Unlimited creative variations


• Faster testing cycles


• Up to 96% cost reduction

Key Takeaway

Most people think AI products are about models.

They’re not.

They’re about systems.

AI models generate outputs.

Orchestration creates value.

Final Thoughts

This project wasn’t just about automation.

It was about building:

• A scalable creative engine


• A reliable attribution system


• A product that improves performance marketing

If you're building with AI, focus less on individual models

and more on how they work together.

Full Case Study

If you want the full breakdown (business + product + impact):

👉 We Built an AI That Creates UGC Ads in Minutes

Let’s Discuss

Curious how others are handling:

• Multi-model orchestration?


• AI latency issues?


• Attribution challenges?

Drop your thoughts 👇