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:
- User uploads a product image
- Selects an AI actor
- Scenario API generates visual assets
- Creatify API renders video
- Orchestration layer combines everything
- 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 👇
Top comments (0)