Computer Vision

A Failover-Chained Text-to-Image Service Built on Three Stable Diffusion Models

How Pfactorial Technologies built a text-to-image web application that turns any prompt into a downloadable image, with automatic failover across three diffusion models.

August 21, 2026

OUTLINE

ENGAGEMENT SNAPSHOT

Pfactorial_Case_Study_ScribblePix image 1

Figure 1 - Key figures from this engagement, at a glance.

EXECUTIVE SUMMARY

Our client wanted a simple way for users to type a text prompt and get back a real, downloadable image - a tool for personalized graphics and dynamically generated visual content - without asking users to understand which diffusion model or API sits behind it.

The naive version of this is a single call to a single hosted model, which is fine until that model is overloaded or briefly unavailable - a common condition for hosted inference endpoints - at which point the naive version simply fails the user's request. The tool needed to keep working through that without the user ever seeing the failure.

Pfactorial built a Flask application that chains three Stable Diffusion models with automatic failover, converts whatever comes back into a consistent image format, and serves it to the user for preview and download.

Why this engagement is representative This engagement demonstrates Pfactorial's approach to building reliably on top of third-party generative AI APIs - chaining redundant model endpoints so a user's request succeeds even when the primary model doesn't, rather than exposing that fragility directly to the user.

THE CHALLENGE

Turning a hosted diffusion API into a dependable product feature ran into problems that only show up under real usage, not a clean demo.

1. A single hosted model endpoint isn't reliable enough on its own

Hosted inference APIs can be overloaded or briefly unavailable, and a tool that calls just one model endpoint fails visibly to the user exactly when that happens.

2. Different diffusion models return different raw formats

Image bytes coming back from different model endpoints need to be normalized into one consistent, downloadable format regardless of which model in the chain actually generated the result.

3. Preview and download needs don't match

A fast, lightweight preview in the browser is a different requirement from a higher-resolution file the user actually wants to keep, and the app has to serve both from the same generation request.

4. The interface has to stay simple despite the complexity behind it

A user typing a prompt shouldn't need to know or care that three different models and a failover chain are involved - the experience has to read as one simple text-to-image tool.

The real brief Not "call a text-to-image API and show the result" but "make prompt-to-image generation dependable, even when the model behind it isn't."

THE SOLUTION

Pfactorial built a Flask application that sends each prompt through a chain of three Stable Diffusion model endpoints with automatic failover, then normalizes and serves the result for preview and download.

Pfactorial_Case_Study_ScribblePix image 2

Figure 1 - A single prompt can transparently traverse up to three model endpoints before the user ever sees a result.

Architectural principles

Redundancy at the model layer, not just the infrastructure layer - three independent Stable Diffusion endpoints are chained so a single overloaded or unavailable model doesn't fail the user's request - the failover happens invisibly, behind one API call from the app's perspective.
Normalize output regardless of source - whichever of the three models actually generates the image, its raw bytes are converted into the same PNG format before the user ever sees it, so the failover chain is invisible in the result.
Keep the interface as simple as the underlying chain is complex - the user experience is one text box and one generate action - the three-model failover chain, retries, and format conversion all happen behind that single interaction.
Log failures without surfacing them - each failed attempt in the chain is logged for diagnosis, while the user only ever sees the successful result from whichever model ultimately generated it.

CAPABILITIES DELIVERED

Each capability turns a text prompt into a reliable, ready-to-use image with minimal friction for the user.

CAPABILITY	WHAT IT DOES
Text-to-image generation	Generates an image from any user-supplied text prompt using Stable Diffusion.
Automatic model failover	Falls through Stable Diffusion 2.1, then 1.5, then 1.4 automatically if a model endpoint fails or is overloaded.
Consistent image formatting	Converts whatever raw image bytes come back into a standard PNG regardless of which model generated it.
Inline preview	Displays the generated image directly on the page via an embedded base64-encoded preview.
Direct download	Serves the generated image as a downloadable file at a dedicated download endpoint.
Session-based image tracking	Associates each generated image with the user's session and prompt text for retrieval on download.

Pfactorial_Case_Study_ScribblePix image 3

Figure 2 - The failover chain absorbs model-level failures so the user experience stays a single, simple request.

Design note The three models are chained in a deliberate order - newest and highest-quality first, older and more broadly available models as fallback - trading a small amount of average image quality on rare failover cases for a request that reliably succeeds rather than one that occasionally fails outright.

ENGINEERING FOR SCALE AND RELIABILITY

Three decisions kept the prototype dependable despite resting entirely on third-party hosted models.

Sequential model failover instead of a single hosted endpoint

Chaining Stable Diffusion 2.1, 1.5, and 1.4 in sequence means a single model's overload or outage degrades output quality at worst, rather than failing the request outright.

Format normalization as its own processing step

A dedicated image-preprocessing function converts every response to PNG via Pillow, decoupling the rest of the application from whatever raw format each individual model endpoint happens to return.

Session-scoped file naming instead of a database

Generated images are tracked by session and prompt text rather than a database record, keeping the prototype's storage model as lightweight as the rest of the single-script application.

DELIVERY APPROACH

The engagement built the generation chain first, then the formatting and delivery layers around it.

1. Model integration - wired calls to the Stable Diffusion 2.1, 1.5, and 1.4 hosted endpoints.

2. Failover chain - built the sequential fallback logic that tries each model in order until one succeeds.

3. Image normalization - built the Pillow-based conversion step that formats every result as a consistent PNG.

4. Preview and download routes - built the inline base64 preview and the dedicated file-download endpoint.

5. Interface - built the HTML/CSS/JavaScript prompt-input form and result display.

RESULTS AND IMPACT

Pfactorial_Case_Study_ScribblePix image 4

- Key outcomes from this engagement.

The application is built and functioning end-to-end: a user types a prompt and receives a generated image, previewed at 256×256 in-browser and available as a 768×768 download, with generation automatically falling through up to three model endpoints if needed.

Because the failover chain and format normalization sit behind one simple interface, the user experience stays a single, reliable text-to-image interaction regardless of which of the three underlying models actually produced the result.

What it enabled commercially

The client now has a working, demonstrable text-to-image prototype that shows generation can be made dependable on top of third-party hosted models, informing a production build decision that could include scaling to concurrent users or bringing a model in-house.

WHY PFACTORIAL

This engagement reflects Pfactorial's applied generative AI practice - building genuine reliability on top of third-party model APIs through redundancy and normalization, rather than exposing their rough edges directly to the end user.

Pfactorial_Case_Study_ScribblePix image 5

- Service lines this engagement draws on.

Engagement enquiries Pfactorial Technologies works with teams who want generative AI capabilities - image, text, or otherwise - delivered as dependable product features rather than a fragile demo wrapped around a single API call. If you're evaluating a generative AI prototype, we're happy to give you an honest read on scope and risk before anyone commits to anything. · pfactorial.ai

APPENDIX A - TECHNOLOGY STACK

The technology stack underpinning the system, grouped by the layer it serves.

Pfactorial_Case_Study_ScribblePix image 6

Result and Analysis

ENGAGEMENT SNAPSHOT

How Pfactorial Technologies built a text-to-image web application that turns any prompt into a downloadable image, with automatic failover across three diffusion models.