Justin

Command Palette

Search for a command to run...

Back to project archive
Completed2026ai-data

SD Multi-Modal Platform: Portfolio-Ready Stable Diffusion Platform

A product-shaped AI generation demo unifying txt2img, img2img, inpaint, post-processing, queue state, assets, and history

SD Multi-Modal Platform is a FastAPI + React generative AI platform demo. The refreshed version keeps the full-mode Stable Diffusion / SDXL / ControlNet / post-processing architecture, while adding a mock-safe demo mode so the public GitHub Pages site, screenshots, walkthrough video, and local smoke tests work without GPU access, model weights, Redis, or external services.

Live DemoView GitHubDemo RecordingRead README

Verified Demo Recording 1

Copied by the portfolio quality pass from existing project demo media.

25 screenshots5 demo videos

Media overview

Browse the project screenshots and recorded walkthroughs.

Project links and demo readiness

live

Live Demo

Open the verified live demo when available, or use the internal run guide for manual demo preparation.

github

View GitHub

Open the public repository when available, or review the source-access status captured by this case study.

video

Demo Recording

Open the demo recording when available, or use this section as the recording checklist for the project.

documentation

Read README

Open the project README when available, or use this case study as the documentation baseline.

Project overview

This project now demonstrates more than the ability to call Stable Diffusion. It shows how local AI inference capabilities can be packaged into a product-shaped platform that is understandable, testable, deployable, and safe to present in an interview. The public demo uses mock-safe mode because a portfolio demo needs to be stable and reproducible. Reviewers can immediately see the prompt workbench, generated result, queue state, assets/history, and architecture notes. Locally, the FastAPI mock backend can be started and verified with a smoke test against the same API concepts. Full mode still retains the real-model architecture: ModelManager coordinates SDXL, SD 1.5, and SD 2.1; the post-processing layer maps to Real-ESRGAN, GFPGAN, and CodeFormer; and Redis/Celery handles long-running queue work. The README documents the storage layout for models, caches, outputs, assets, and logs so large local files and private runtime paths stay out of Git.

My role

Independent developer across full-stack platform design, API implementation, React workbench, mock-safe demo engineering, architecture documentation, deployment, and portfolio integration.

Problem

Stable Diffusion projects often remain stuck in a local-only state: reviewers need model weights, CUDA, Redis, Celery, post-processing weights, and environment-specific paths before they can understand the value. This repo already had many API and service modules, but it needed a stable public entrypoint for demos, screenshots, video capture, and smoke testing.

Solution

I reorganized the project around two modes. Full mode preserves the ModelRegistry, Diffusers pipelines, Redis/Celery queue, assets/history, and post-processing services. Mock-safe mode uses deterministic PIL rendering behind the same FastAPI routes, so the workflow remains demonstrable without large models or GPU hardware. The React workbench can connect to the mock API, and the repo now includes a GitHub Pages demo app, Playwright screenshot/video capture, README Mermaid diagrams, and an interview runbook.

Current outcome

The public showcase path is now usable: GitHub Pages opens directly into a product workbench, the portfolio page includes cover media, screenshots, and a WebM walkthrough, and the local mock backend can be smoke-tested through health, models, txt2img, img2img, and queue graceful-degradation checks. The React typecheck/build workflow is also reproducible.

Highlights

  • First viewport shows the product itself: prompt panel, generated result, queue monitor, assets/history
  • Mock-safe demo mode runs core API flows without GPU access, model weights, Redis, or external services
  • FastAPI v1 routers separate generation, postprocess, assets, history, models, queue, and health boundaries
  • React + TypeScript workbench groups prompt presets, mask workflows, queue state, assets, and history
  • Graceful degradation keeps the API bootable when optional ML/runtime dependencies are missing
  • README diagrams cover product flow, system architecture, data flow, queue lifecycle, deployment, and module organization

Engineering challenges

  • Turning a GPU/model-dependent AI project into a public demo without pretending mock output is real model output
  • Preventing optional ML package import failures from blocking the entire FastAPI application
  • Integrating the project into a portfolio repo with unrelated local changes while staging only this project's slug and media

Target users

  • Portfolio reviewers and interviewers
  • Technical readers who need a quick view of purpose, stack, and maturity

Technical highlights

  • Detected technical signals: Python, FastAPI, React, TypeScript, Vite, PyTorch, Diffusers, Hugging Face Transformers, Redis, Celery, Pydantic, Pillow, Docker, GitHub Pages
  • README evidence exists and can support a fuller reviewed case study
  • A public GitHub repository is linked for source traceability

Architecture

This case study is generated from the portfolio catalog pipeline using README, Git metadata, package/build configuration, and media signals. The final architecture narrative still needs source-level review. Current detected technology signals include: Python, FastAPI, React, TypeScript, Vite, PyTorch, Diffusers, Hugging Face Transformers, Redis, Celery, Pydantic, Pillow, Docker, GitHub Pages.

Data flow

A public data-flow narrative is not fully reviewed yet. If the project includes data processing, AI pipelines, or backend APIs, the next pass should document input, processing, storage, and UI/output flow end to end.

Project structure

sd-multimodal-platform/
  README.md              # project documentation, when available
  source files           # implementation reviewed by local audit
  package/build config   # detected capability signals

Setup / Run guide

This project does not expose a verified runnable web command yet. Review the README/source tree and add exact install, run, test, and build commands before interview use.
No verified build command was detected. Treat the current portfolio page as a case-study placeholder until build steps are reviewed.

Future improvements

  • Complete the production-quality README, screenshots, and demo recording
  • Add architecture diagrams, data-flow notes, and key technical decisions
  • Verify build/test status and update the portfolio release report

Interview notes

  • State the current maturity and demonstrable scope first
  • Focus on verified stack, source structure, and completed behavior
  • Do not claim unverified deployment, video, or test coverage as finished

Next steps

  • Deploy a live backend on Render, Railway, or Fly.io for remote API interaction
  • Add more real model output examples alongside the mock-safe workflow
  • Expand end-to-end coverage for Redis/Celery full queue execution and GPU model switching

Related projects