A cool demo is not a production strategy. That's the first thing you learn building enterprise software. It's easy to get excited when you see a proof of concept that just works. And right now, nothing demos better than generative AI.
Just this week, as Hacker News reported, a post made the rounds showing that AI-generated posters don't have to be horrible. The author is right. With careful prompting and some iteration, you can get surprisingly good results out of models like DALL-E 3 or Midjourney. It feels like magic. But for a CTO or an engineering lead, that magic is also a misdirection. The real work, the part that breaks, starts the moment you try to scale that process from one poster to one thousand dynamic assets inside your application.
Your marketing team wants to automatically generate a unique social card for every new product in your catalog. Your product manager for NutriScan wants to show users a beautiful, AI-generated image of their logged meal. These sound like fantastic features. But if your first thought is to just hook up an API call to a generative model in your backend, you're building a system that's destined to fail. The problem isn't the prompt. It's the pipeline.
The Lure of the One-Off vs. The Reality of Scale
Making a single event poster is an artisan process. You write a prompt, you get a result. Don't like it? You tweak the prompt, maybe change the seed, and try again. You, the human, are the quality assurance gate. This workflow is fine for a one-off marketing asset. It's a disaster for a software product.
Let's take a real-world example. At AgileStack, we worked with an e-commerce client who wanted to generate Open Graph (OG) images for their 50,000 product pages. These are the preview images you see when you share a link on Slack or Twitter. The idea was simple: feed the product title and a short description to an AI model and get a unique, compelling image for each one.
In the demo, it worked beautifully. A photorealistic image of a sleek, minimalist desk chair, model 'ErgoMax 5000', in a sunlit office. The result was stunning.
But then came the questions. What happens when the product is '3-inch PVC Pipe Connector (10-pack)'? The AI's creative interpretation was, to put it mildly, not what they wanted. What happens when the model is updated by the provider and the entire visual style changes overnight? How do you ensure the company logo is always present in the bottom-right corner, perfectly rendered and not warped into a surrealist nightmare?
The one-off workflow of a designer tweaking prompts doesn't scale to 50,000 products. You can't manually review every image. You need a system, an automated pipeline. And that's where the engineering challenges begin to pile up, challenges that generative AI, in its current state, is uniquely bad at solving.
Your Brand Guidelines Are Not an API Endpoint
Consistency is the bedrock of enterprise software and brand identity. Your company has a specific shade of blue. It's #3A7DFF, not #3A7DFE and definitely not whatever the AI feels like generating today. Your logo has clear space rules. Your typography is chosen for a reason.
Generative AI models are, by design, non-deterministic. They are black boxes that provide creativity, not precision. You can't pass your brand book as a parameter to the API call. This leads to a few massive problems in production:
1. The Brand Drift Problem
Even if you get a prompt that produces results in your brand's style today, it won't tomorrow. We've seen this happen. A model update at the provider level can subtly shift the color palette, the texture, or the composition of the images it generates. Suddenly, all your new social cards look slightly different from the old ones. It's a slow, insidious corruption of your brand identity.
2. The Impossibility of Programmatic Validation
How do you write a unit test for 'looks good'? How do you create an integration test to confirm an image 'matches our brand style'? You can't. You can run basic checks, like image dimensions or file size, but you can't programmatically validate the aesthetic quality or brand alignment of a generated asset. This means you're flying blind. You're deploying a system that can, at any moment, start producing off-brand or just plain weird content, and you won't know until a customer complains.
A traditional templating system, using a library like sharp in Node.js or a service like Cloudinary, is predictable. It's boring, but it's reliable. You provide a template, data, and your specific brand assets, and it produces the exact same result every single time. It's testable, versionable, and stable.
Runtime Generation is a Performance and Budget Nightmare
Let's say you solve the consistency problem. The next wall you'll hit is performance and cost, especially if you're considering generating images at runtime (during a user request).
When a link to your site is shared for the first time, the service (like Twitter or Slack) scrapes the URL to fetch the OG image. If you're generating that image on the fly, you're adding the entire latency of the AI model's API call to that request. We're not talking milliseconds. We're talking seconds. A DALL-E 3 API call can take anywhere from 5 to 15 seconds. That's an eternity. Most scrapers will time out, leaving you with no preview image at all.
And then there's the cost. At roughly $0.08 per HD image, generating an OG image for each of those 50,000 products costs $4,000 upfront. What if you want to generate personalized welcome banners for new users of your MailStack service? If you get 1,000 signups a day, that's $80 a day, or nearly $30,000 a year, for one feature. It's a cost that scales linearly with user engagement, which is often the opposite of what you want in your infrastructure budget.
Generating assets should be a build-time concern, not a run-time one. It's the same principle we apply to rendering web pages. We prefer Static Site Generation (SSG) or Incremental Static Regeneration (ISR) over Server-Side Rendering (SSR) for performance because the work is done ahead of time. The same logic applies here.
A Better Architecture: The Asset Factory Pipeline
Instead of treating generative AI as a magic API call, you need to treat it as one component in a larger, more robust system. We call this the 'Asset Factory' pattern. It’s a pipeline that gives you the creative power of AI without the risks of inconsistency, poor performance, and runaway costs.
It’s a CI/CD pipeline for your creative assets. Here’s how it works.
1. Generate at Build-Time
Never generate an image during a live user request. Instead, trigger the generation process when the underlying data changes. For a blog post, this happens when you merge the article. For a product, it's when the product details are updated in the CMS. The asset is generated once and stored on a CDN, like S3 or Cloudflare R2. All subsequent requests for that image are fast and free.
2. Composite and Control
Don't rely on the AI to handle everything. Use it for what it's good at: creating interesting, unique backgrounds or abstract concepts. Then, use a deterministic tool to composite your brand elements on top.
This hybrid approach gives you the best of both worlds. You get a unique background from the AI, but your logo, text, and other critical brand elements are perfectly rendered every single time. A simple Node.js script using the sharp library can handle this beautifully.
Here’s a rough idea of what that code might look like (this is pseudocode):
import { openai } from './api/openai';
import sharp from 'sharp';
// This function runs at build time, not request time.
async function createProductOgImage(product) {
// Step 1: Generate the creative background with AI
const response = await openai.images.generate({
model: 'dall-e-3',
prompt: `Abstract, beautiful background related to: ${product.category}`,
n: 1,
size: '1024x1024'
});
const aiImageUrl = response.data[0].url;
const aiImageBuffer = await fetch(aiImageUrl).then(res => res.arrayBuffer());
// Step 2: Composite brand elements deterministically with Sharp
const finalImageBuffer = await sharp(Buffer.from(aiImageBuffer))
.composite([
{ input: './assets/logo_watermark.png', gravity: 'southeast' },
{
input: {
text: {
text: `<span foreground="white">${product.name}</span>`,
font: 'Inter Bold',
width: 800,
height: 200,
rgba: true
}
},
top: 100,
left: 112
}
])
.png()
.toBuffer();
// Step 3: Upload to your CDN
await uploadToS3(`og-images/${product.slug}.png`, finalImageBuffer);
}
This pipeline is testable, reliable, and decouples your application from the performance of a third-party AI service.
3. Implement Human-in-the-Loop Review
For the most critical assets, you can add a manual approval step to the pipeline. The system could generate three to five background options from the AI model. These are then presented in a simple internal dashboard (a perfect use case for a DevStack tool). A designer or marketer reviews the options, clicks 'approve' on the best one, and only then is the final asset composited and pushed to production.
This keeps humans in the loop for creative judgment but automates all the tedious parts of the process.
What This Means for Your Team
It's easy to get caught up in the hype. But as engineering leaders, our job is to look past the demo and architect for reality. Here are the key takeaways:
- Treat Gen AI as an Unreliable Dependency. Don't build critical user-facing paths that depend on the synchronous response of a generative AI API. The latency and unpredictability are too high.
- The Prompt is Only 10% of the Work. The other 90% is building a robust, testable, and cost-effective pipeline to manage the assets the AI creates. This is a software engineering problem, not a prompt engineering problem.
- Favor Build-Time Over Run-Time. Generate assets ahead of time. The performance and cost benefits are too significant to ignore. Your users and your CFO will thank you.
- Control What Matters. Use AI for creative tasks, but use deterministic tools to enforce brand consistency. The hybrid approach is almost always the right answer for a production system.
Before you approve a project to integrate AI-generated images, ask your team to map out the entire asset lifecycle from generation to validation to delivery. If they're just talking about the prompt, they haven't thought it through. Building a real production system is far more complex than a clever one-liner sent to an API.
Building something in this space? AgileStack helps teams ship enterprise-grade software without the consulting-firm overhead. Book a 30-minute call and tell us what you're working on.