Justin

Command Palette

Search for a command to run...

Back to project archive
Prototype2026ai-data

RestorAI Studio — AI Image Restoration Portfolio Workbench

A public, mock-safe AI restoration demo with before/after viewing, pipeline status, and reproducible media

RestorAI Studio is an AI image restoration and super-resolution platform prototype reshaped into an interview-ready portfolio demo. The public demo uses browser Canvas to simulate the inference workflow without GPU, model weights, or external services; the local smoke path exposes a FastAPI + Pillow API to validate upload, processing, and PNG response behavior.

Live DemoView GitHubDemo RecordingRead README

Verified Demo Recording 1

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

23 screenshots4 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

## Overview RestorAI Studio demonstrates how to turn an AI model prototype into an evaluable product demo. The public demo does not assume the user has a GPU or model weights. It presents a browser-based image restoration workbench where users can load samples, tune scale/strength, run a pipeline, compare before/after output, and inspect a job payload. ## Architecture The repository keeps the broader AI service scaffold: FastAPI routers, job manager, metrics/history/export/admin routes, Gradio/CLI/PyQt entries, AI Warehouse model paths, and Real-ESRGAN/GFPGAN/RIFE adapter design. The stable presentation path is delivered through `portfolio-web/` and the `webapp/main.py` demo API. ## Portfolio Value The value is not just the model list. The project shows practical engineering judgment: isolate GPU/model-weight risk, provide a reproducible mock-safe demo, add CI, generate portfolio media, and document the production path clearly enough for users to understand product scope and next steps.

My role

Solo developer (portfolio demo design, frontend demo, FastAPI demo API, CI/CD, documentation, and portfolio integration)

Problem

The original project had a useful AI restoration service architecture, but true model inference depends on large weights, GPU availability, and version-sensitive packages, making it hard for users to launch, inspect, screenshot, or evaluate quickly.

Solution

Split the project into two presentation-safe paths: a pure static GitHub Pages demo whose first screen is the restoration workbench, and a local FastAPI/Pillow smoke API for upload and processing verification. The README now documents the system with Mermaid product flow, architecture, data flow, deployment, and module diagrams.

Current outcome

Delivered a public interactive demo, cover image, desktop/mobile screenshots, and a WebM demo recording. GitHub Actions verifies compile, pytest, API smoke, and static build before GitHub Pages deployment. The real model path is honestly labeled as a prototype scaffold instead of being presented as production-ready inference.

Highlights

  • Product-first first screen: before/after viewer, scenario selector, scale, restore strength, pipeline status, and job payload
  • Mock-safe public demo requiring no GPU, model download, backend, or external service
  • FastAPI demo API validates upload, Pillow resize/sharpen, PNG response headers, and smoke tests
  • README includes Mermaid product, architecture, data flow, deployment, stack, and module diagrams
  • Playwright-generated cover, screenshots, and WebM demo tour keep media reproducible
  • GitHub Pages workflow runs compile, pytest, smoke, and static build before deployment

Engineering challenges

  • Creating a convincing AI product workflow without relying on brittle GPU/model infrastructure
  • Turning scattered FastAPI, Gradio, CLI, PyQt, and model scaffolding into an explainable architecture
  • Being explicit about prototype boundaries while still making the project easy to evaluate

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, Pillow, JavaScript, Canvas, Playwright, PyTorch, Real-ESRGAN, GFPGAN, RIFE, Gradio, PyQt, GitHub Pages, Docker
  • 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, Pillow, JavaScript, Canvas, Playwright, PyTorch, Real-ESRGAN, GFPGAN, RIFE, Gradio, PyQt, GitHub Pages, Docker.

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

restoreAI-studio/
  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

  • Complete Real-ESRGAN/GFPGAN/RIFE lifecycle and CPU/GPU fallback
  • Consolidate prototype API routers into one production contract
  • Add true-model integration tests, model weight health checks, and artifact persistence

Related projects