What is Creative Automation?
Creative Automation is the process of generating visual content, images, videos, designs, programmatically, often in response to structured inputs like product data, user attributes, or campaign parameters.
Instead of designing each asset manually, creative automation enables you to define templates and rules that the system uses to produce content at scale.
This approach accelerates production workflows and enables personalization at scale, multivariate testing, and omni-channel consistency without stretching design resources.
Creative Automation & Generative AI
Of course, you cannot talk about creative automation in this day and age without also discussing the role of generative AI. Gen AI introduces intelligent content generation into the pipeline making it easy to generate headlines, product descriptions and entire design elements like illustrations, videos or voiceovers and background music.
When paired with a robust editing and rendering engine like CE.SDK, generative AI becomes even more powerful. A design editor that sits at the intersection between the human decision maker and raw AI generated creatives ensures that those creatives can be curated, refined and deployed in an orderly fashion. This usually works by employing design templates that provide extension points for dynamic data through variables and placeholders and that AI generated content can be merged into for a brand-safe final creative.
Our customer Omneky provides an excellent example of how these components can be orchestrated for maximum efficiency and productivity. Omneky is an ad tech platform that uses generative AI to automatically generate creatives and ad copy for a company based on their product and positioning, these are then interpolated into CE.SDK template to create ad variations. These variations are then tested across ad channels and the results used to inform further refinement and ad selection. This is a prime example of how to combine creative automation and editors to tame the chaotic fountain of AI creatives.
How CE.SDK Enables Creative Automation
Let us get into the meat and potatoes of creative automation and sketch out the requirements of a creative automation solution and an end to end example with CE.SDK. IMG.LY’s CreativeEditor SDK (CE.SDK) offers both a user interface for design-time flexibility and a graphics processing engine API for runtime automation.
Design Once, Automate Everywhere
With CE.SDK, you create design templates that define placeholders, variables, and lockable design elements. These templates ensure brand consistency while allowing dynamic content generation. Whether you're building social ads, team cards, or product visuals, the structure remains stable while the content varies. The diagram below illustrates these components using a classical mail merge example. The user creates a design template within the editor and defines certain variables like first_name and address, a data source of address data can now be merged with this template using the engine API: variable: setString to create an individualized postcard for every data point in the set:
Under the Hood: CE.SDK Architecture
In order to fully understand how to implement creative automation workflows with CE.SDK we need a basic mental model of its architecture. CE.SDK is built on two distinct layers, giving you total flexibility and control.
The UI Layer is the customizable frontend allowing users to design and edit different media types from photos, design compositions such as collages, videos or mixed media.
The Engine Layer exposes the Creative Engine, CE.SDK’s core rendering and editing engine, through an API. The architecture of CE.SDK is built around a layered approach that separates concerns while ensuring cross-platform consistency:
- Engine Core (C++)At the foundation lies the Creative Engine, a high-performance rendering and editing core written in C++. This is where all processing, layouting, and rendering logic happens, guaranteeing precision and fidelity.
- API LayerOn top of the core sits the API Layer, which exposes the engine’s capabilities in a consistent, high-level interface. This abstraction allows developers to focus on creative logic without dealing directly with low-level rendering details.
- Cross-Platform TargetsThe same engine and API are cross-compiled to iOS, Android, Web, and server environments, ensuring that rendering results remain identical regardless of platform. This uniformity is critical for automation workflows, where assets may be produced or consumed across multiple devices and services.
- Headless ModeBeyond powering interactive UIs, the engine can also be run headlessly. In this mode, CE.SDK operates without a frontend, enabling automated scenarios such as bulk rendering of images or videos, dynamic template generation, and data-driven personalization at scale.
This modular architecture ensures that whether you are building a custom editing UI or running automated creative workflows on the server, every output is backed by the same reliable, cross-platform engine.
How to Integrate Creative Automation into Your Workflow
Step 1: Integrate CE.SDK
Even if you don’t plan to use the CE.SDK UI for end users, you still need to spin it up locally or within internal tooling to create templates. Let’s install CE.SDK and configure it to the advanced UI, in Creator mode.
CE.SDK by default comes with two UI flavors. The design or default UI config exposes all the essentials for productive design editing by most users, ideal for adapting templates. An advanced UI fine grained editing controls and the ability to define placeholder elements and control what users can change.
The "Creator" role allows setting constraints on template elements, while the "Adopter" role is focused on adapting these elements.
- Creator: Set constraints and manage template settings.
- Adopter: Edit elements within the bounds set by the Creator.
Install CE.SDK following one of our guides and explore the entire demo here.
You can find the complete demo here
Configuring CE.SDK for Template Creation
Below is a sample configuration. Notice how we set role: 'Creator' and view: 'advanced' to unlock template authoring features. We also configure an onSave callback to export complete template archives — these include all necessary resources (images, fonts, stickers, etc.) in a self-contained package. Archives are what you’ll deliver to adopters or use for data-driven automation later.
const config = {
theme: 'dark',
role: 'Creator',
callbacks: {
onExport: 'download',
onUpload: 'local',
onSave: async (sceneString: string) => {
try {
// assumes engine is available in scope
const blob = await engine.scene.saveToArchive();
const formData = new FormData();
formData.append('file', blob);
await fetch('/upload', {
method: 'POST',
body: formData,
});
} catch (error) {
console.error('Save failed', error);
}
},
},
ui: {
elements: {
view: 'advanced',
panels: {
inspector: {
show: true,
position: 'right',
},
},
dock: {
iconSize: 'normal',
hideLabels: true,
},
navigation: {
action: {
export: {
show: true,
format: ['image/png', 'application/pdf'],
},
},
},
},
},
};
Step 2: Build Smart Templates
With CE.SDK running in Creator mode, we can now define editable templates. These templates can include:
- Named blocks → Easy-to-reference design regions (e.g.,
PodcastCover,PodcastBadge). - Variables → Text placeholders enclosed in double curly braces (e.g.,
{{Message}},{{PodcastName}}).
For example, here’s a podcast cover template with two text variables and named blocks. The variables make it possible to inject data programmatically later.
Podcast template:
- Variables: {{Message}}, {{PodcastName}}
- Named blocks: PodcastCover, PodcastBadge
Since we’re in Creator mode, we can also enforce brand constraints, for instance, locking background colors, logos, or fonts so that adopters (or automated processes) don’t accidentally override brand-critical assets.
Step 3: Automate Asset Creation
Once you have a template, the next step is automation. Using the headless Creative Engine, you can:
- Populate placeholders with external data (e.g., from APIs).
- Swap images, update text variables, or adjust styling dynamically.
- Export the results at scale into formats like PNG, PDF, or even video.
Example: Dynamic Podcast Covers
In this demo, we connect to the Apple iTunes API to fetch podcast data. Whenever a podcast is selected (or user input changes), our fillTemplate function updates the CE.SDK scene.
Key concepts:
- Blocks API → Query template blocks by name (
engine.block.findByName('PodcastBadge')) and replace their fills. - Fills → Blocks can have images, solid colors, gradients, or videos. For podcast artwork, we set
imageFileURI. - Variables API → Set text variables directly (
engine.variable.setString('Message', 'Hello World')).
const fillTemplate = (engine: CreativeEngine, page: number) => {
let { r, g, b } = backgroundColorRGBA;
engine.block.setColor(page, 'fill/solid/color', { r, g, b, a: 1 });
if (podcast) {
const photoBlocks = engine.block.findByName('PodcastCover');
photoBlocks.forEach((photoBlock: number) => {
const photoFillBlock = engine.block.getFill(photoBlock);
engine.block.setString(
photoFillBlock,
'fill/image/imageFileURI',
podcast.artworkUrl600
);
});
}
const colorTheme = getThemeColorFromBackgroundColor(backgroundColorRGBA);
const [badgeBlock] = engine.block.findByName('PodcastBadge');
engine.block.setString(
engine.block.getFill(badgeBlock),
'fill/image/imageFileURI',
caseAssetPath(
`/podcast-badge-${colorTheme === 'light' ? 'black' : 'white'}.png`
)
);
// set text variables
engine.variable.setString('Message', debouncedMessage || '');
engine.variable.setString(
'PodcastName',
podcast ? podcast.collectionName : '')
// set text colors based on background theme
const [messageBlock] = engine.block.findByName('Message & Name');
const rgb =
colorTheme === 'dark' ? { r: 1, g: 1, b: 1 } : { r: 0, g: 0, b: 0 };
engine.block.setTextColor(
messageBlock,
{ ...rgb, a: 0.75 },
0,
"{{Message}}".length
);
engine.block.setTextColor(
messageBlock,
{ ...rgb, a: 1.0 },
"{{Message}}".length
);
};
At this point, you’ve created a data-driven creative automation pipeline:
- Templates authored with placeholders and constraints.
- Dynamic population of text and image fields via external data.
- Export to high-quality assets at scale.
This workflow is the foundation for personalized marketing campaigns, automated content production, and AI-driven design pipelines with CE.SDK.
Creative Automation isn’t just about speed it’s about scalability, consistency, and customization. IMG.LY’s CE.SDK gives you the tools to build powerful, flexible automation workflows tailored to your brand and users.
Start you free trial today and integrate content automation into your application.