Bildgenie.ai

Status

Bildgenie is currently in long-term maintenance mode. I’m not actively developing it any further because my time and personal priorities have shifted. The platform runs, the code is solid, everything is secured.

How I got there

I started Bildgenie with zero knowledge. Lines of code made the hairs on the back of my neck stand up. I didn’t know how to set up a server. I didn’t know how to bring anything live. I didn’t even know what Git or GitHub was.

Bildgenie was the spark. The project that really shaped me. Looking at code with different eyes.

What I learned along the way I couldn’t have made up beforehand:

Git, the painful way. The code was gone more than once. Completely. Without Git the project would have been dead by day three.
Refactoring. The folder structure was a drama. Refactoring is one of the driest pieces of IT work you can do, and it’s absolutely necessary. You build structure and order at the same time.
VPS hosting. Where do I put this code stuff live? Answer: a VPS costs a few euros a month on every major platform. Set it up yourself, harden it, secure it.
Trashing databases. Killed the prod DB once, right before beta test. You only learn moments like that once.

After more than a year of development, I hit the point where I could honestly say: this works. I built something pretty much solo (with Claude alongside) that senior devs would spend weeks on. The time wasn’t a wasted investment. The opposite. It was by far the best investment of time I’ve ever made. Just the knowledge alone, the building of server structures, spinning up and trashing databases, that was worth every hour.

Bildgenie will always be the point that brought me into IT. I’m immensely grateful to this project for that. Maybe one day it goes fully live again, the structure is there. But alone I won’t pull it off, and it’s a giga project. Maybe not in terms of code, but in terms of me personally and how I grew, definitely.

The technical side

What Bildgenie is

A German-language SaaS platform for AI-generated images and videos. Instead of being yet another “ChatGPT for images” with an empty prompt field, Bildgenie bundles specialized generators for concrete use cases: LinkedIn profile pictures, product photos, themed calendars, ad videos, image repair and so on. Each generator has its own UI, its own input fields, its own model setup prepared in the background.

It’s not an attempt to compete with OpenAI. It’s a product layer over existing AI models. Exactly the layer where most of the money is right now.

Coins instead of subscription

The business model is deliberately not a subscription squeeze. Users buy coin packs and use them as needed. An image generation costs between ~20 and ~120 coins, a video depending on length and quality up into four digits. Payment runs through Stripe.

Why this works:

No pressure on casual users to justify a monthly bill
Fair scaling: someone who wants five images a month doesn’t pay for five hundred
Clear cost transparency before every generation. The price sits right on the button
Clean accounting: every coin movement runs through database transactions with audit trail, not over volatile counters

Three-layer architecture

Classic three-layer setup with one decisive twist.

Frontend. React SPA with Tailwind. All generator definitions, meaning fields, prices, validation, endpoints, live in a single config file. Sounds unspectacular, is the backbone: adding a new generator means adding an entry to this config. No copying components, no maintaining prices in three places, no drift between UI and backend.

Backend. Flask, SQLAlchemy, MySQL, Redis. Small and unflashy. The backend deliberately doesn’t do what most people would expect: it doesn’t generate images itself. It’s an orchestrator, an accountant and a guard.

Orchestration. n8n webhooks as a layer between backend and AI providers. This is the point that makes Bildgenie technically really strong, and at the same time the most invisible.

n8n as middleware

Instead of sending requests to AI providers directly from the Flask code, every generation job goes to an n8n workflow first. The workflow receives the payload, transforms it into the format the respective provider expects (KIE.AI and others), waits for the result or returns a task ID for long-running jobs, and ships the result back in a format Bildgenie can handle uniformly.

What that means in practice:

Providers are swappable. When an AI provider gets more expensive, breaks or a new one arrives with better models, the n8n workflow gets rebuilt. Not the backend. No deployment, no code review, no risk for live operations.
Prompt engineering in one place. The system prompts, negative prompts and model parameters that make each generator what it is, all live in n8n. Reading the backend, you don’t see a single prompt. Just webhook URLs.
Faster iteration. A generator tweak doesn’t need a backend deploy. Change workflow, save, runs.
Clear separation of concerns. Backend for auth, coins, validation, logging. n8n for AI logic. Frontend for UX. Every layer has one job.

Sync vs. async

Images usually finish in seconds. Videos take minutes. Bildgenie handles both differently.

Sync path (e.g. simple image generation): request in, image out, coins booked in the same moment.

Async path (e.g. videos): the server returns a task ID immediately. The frontend polls that task ID with exponential backoff: short intervals at first, longer gaps later, defined max. While waiting, the user can refresh the page or close the tab. The running job is locally persisted and gets recovered on return.

That’s robust because the browser doesn’t hang in a four-minute request, network hiccups don’t lose generations, and AI providers don’t get flooded with constant polling.

Local gallery, on purpose

Generated images and videos don’t end up on the Bildgenie server. They live in the browser’s IndexedDB. Deliberate architectural decision with several advantages:

Data minimization. Bildgenie doesn’t keep user generations long-term. What sits in the user’s browser belongs to the user.
GDPR friendly. No question about retention periods for content that was never centrally stored.
Cost. No S3 bucket growing with every active user.
Performance. Gallery opens instantly. No server round trip.

Trade-off: switching browsers means losing the local gallery. For a platform where the result usually gets downloaded or used immediately anyway, that’s an acceptable compromise. For power users an optional cloud sync would be a clear premium hook for later.

Three principles holding the setup together

What keeps maintenance lean despite the complexity:

Single source of truth everywhere. Prices, generator definitions, webhook URLs, environment variables, exactly one source for each. No extra effort on changes.
External services for everything that isn’t core business. Stripe handles payments. Sentry handles error monitoring. n8n handles orchestration. AI providers handle AI. Bildgenie itself handles auth, coin accounting and UI. And does that well.
Deliberate simplicity. No microservice madness, no Kubernetes, no self-hosted models. One Flask app, one MySQL DB, one Redis. What you don’t have can’t break.