Inspiration

Training and safety videos are supposed to teach what's in a written procedure — but procedures change. A single line update (like "assembly point A" → "assembly point C") can make one part of a video wrong while the rest is still valid.

Most AI video tools generate once and move on. Teams lose the link between source text and scenes, can't prove what was released, and usually regenerate everything from scratch.

We built SceneLedger for the Backblaze Generative Media Hackathon to show a better model: generate source-linked scenes with Genblaze, store media and provenance on Backblaze B2, verify at release time, and detect exactly which scenes went stale when the source changes.

What it does

SceneLedger is an end-to-end demo for source-linked training media with verifiable release evidence:

  1. Chunks a plain-text source and SHA-256 hashes every paragraph
  2. Plans 3 scenes with Genblaze chat — each scene validated against real source chunks
  3. Generates media — GMI Cloud storyboards + TTS narration (OpenAI fallback per step); clips/captions are honest placeholders
  4. Stores everything on Backblaze B2 — source, plan, media, Genblaze SDK manifests, compare reports, release manifest
  5. Builds release evidence — live SHA-256 verification over every asset and every Genblaze manifest; optional final.mp4 stitch
  6. Detects stale scenes — upload v2, compare, only the scene tied to the changed chunk goes stale
  7. Downgrades release to warning — hashes still verify, but the release is no longer current (superseded by v2)

Live demo: https://sceneledger.vercel.app/project

How I built it

Frontend: Next.js 15, React 19, TypeScript — guided 8-step demo UI, Release Evidence table, Release Package previews (storyboards, narration, final video), B2 object browser grouped by kind.

Backend: FastAPI (Python) — source chunking, Genblaze scene planner, media pipeline, stale detection, release verifier, optional video stitch. Deployed on Render.

Storage: StorageBackend abstraction — Backblaze B2 in production (tenants/demo/projects/{id}/...), local filesystem for offline dev. Asset previews stream via GET /projects/{id}/asset so a private bucket still works in the UI.

Genblaze integration (three steps, each with provenance):

Step Preferred (GMI Cloud) Fallback (OpenAI)
Scene planning DeepSeek-V3.2 strict structured output gpt-4o-mini
Storyboards GMI image queue (Seedream) gpt-image-1
Narration GMI TTS queue (MiniMax) gpt-4o-mini-tts

Every Genblaze run's canonical SDK manifest is stored byte-exact on B2. Release verification checks SceneLedger's SHA-256 and the SDK's verify_hash(). Assets are marked generator: "genblaze" only after a real provider run.

Frontend hosting: Vercel · CORS: SCENELEDGER_CORS_ORIGINS for the Vercel origin.

Challenges I ran into

  • B2 key mapping — public object keys vs logical paths for hash re-verification; centralized logical_path() and read_bytes_public() on the storage layer.
  • Honest partial AI scope — storyboards and narration are Genblaze-powered; clips/captions stay labeled placeholders so we never overclaim "full AI video."
  • Genblaze provenance at release time — storing SDK manifests byte-exact and verifying both content hashes and manifest integrity, not just SceneLedger-side SHA-256.
  • Provider reliability — GMI preflight warnings (permissive fallback) for image/TTS models; per-step OpenAI fallback so one provider failure doesn't kill the demo.
  • Hosted deployment — Render cold starts, ~2 min media generation for 3 scenes, CORS between Vercel and Render, no secrets in the frontend.
  • Stale vs verified — release can be warning (stale scenes) while all asset hashes still verify — had to make that distinction clear in UI and manifest schema.

Accomplishments that I'm proud of

  • Full hackathon loop on production URLs — B2 + Genblaze + GMI Cloud, live at sceneledger.vercel.app
  • Scene-level stale detection — change one paragraph → only scene-003 stale in the warehouse safety demo
  • Release evidence that re-reads from B2 — verify-release recomputes hashes from stored bytes, not cached JSON
  • Genblaze provenance in the release manifest — run IDs, manifest keys, dual hash verification
  • Release Package UI — in-browser previews of storyboards, narration, and stitched final.mp4 from B2 via the API
  • No database, no auth — entire lifecycle durable on B2 with a clean storage abstraction
  • Never faking Genblaze — generator: "genblaze" only after real provider runs; fallbacks recorded honestly

What I learned

  • Provenance is a storage problem — Genblaze manifests belong on durable object storage (B2), not only in API responses.
  • Scene-granular linkage beats whole-video regeneration — chunk hashes → scene status → release warning is a practical compliance story.
  • Genblaze shines when each step leaves a verifiable artifact — planning, image, and TTS each get their own manifest trail.
  • Hackathon demos need honest scope — labeling placeholders and recording fallback reasons builds more trust than claiming full AI video.
  • Provider abstraction matters — GMI preferred + OpenAI per-step fallback made the hosted demo resilient.

What's next for SceneLedger

  • Genblaze-generated scene clips (video models) feeding a fully AI final.mp4
  • Regenerate only stale scenes — the payoff of scene-level provenance
  • Backblaze B2 Object Lock for immutable release evidence
  • C2PA content credentials via Genblaze's manifest embedder
  • Auth, multi-project tenancy, and a real database for production use

Built With

Share this project:

Updates

Submission history