Slate

Slate turns script scenes into storyboards, animatics, shot lists, temp audio, and versioned production archives stored on Backblaze B2.

Comment

Inspiration

Film pre-production is a mess of unversioned files: storyboard artists email PNGs, directors rename shot-list-FINAL2.pptx, and nobody knows which frames a producer actually approved. Version control never made it past engineering. Slate is the pre-production vault cinematic teams deserve. A workspace where a script scene becomes a versioned production pack, and every asset carries provenance like it's shipping to a client.

What it does

Slate turns a script scene into a versioned production pack in one place:

  • Storyboard frames (6 by default, 1–24 configurable), rendered in Slate's own hand-drawn line-engraving language
  • Mood board, visual style bible, and character reference sheet
  • Shot list with captions, temp audio, and an animatic MP4 placeholder
  • A production pack ZIP with a provenance manifest and SHA-256 hash verification on every generated file Each generation pass becomes a version. Generate Version 2, compare it side-by-side with Version 1, approve the final pack, and publish it to a public review page with token-gated review links for packs still in review.

How we built it

  • Frontend: Next.js 16 with a strict design system - the UI is drawn as a witnessed utility-patent sheet: india ink on bond, hairline rules, 45° section hatch, and carmine annotation ink reserved for examination and failure.
  • Backend: FastAPI + SQLAlchemy, owning project/version state, the pipeline runner, SSE live progress, storage, manifests, and hash verification.
  • Pipeline: Mock-first. GENERATION_MODE=mock produces deterministic assets so the demo runs end-to-end with zero provider keys; real providers (GMI Cloud via the genblaze SDK) plug into the same event and manifest contract.
  • Security: Cookie sessions, PBKDF2-SHA256 password hashes, CSRF tokens, rate limiting, and private-asset access rules.
  • Deployment: Vercel frontend + Render (FastAPI + Postgres), same-origin rewrite proxy for the API.

Challenges we ran into

  • Keeping mock generation deterministic while preserving the exact event and manifest shape of real generation.
  • Drawing the patent-sheet illustration language in generated PNGs so mock assets stay on-world.
  • Deploying a cookie-auth app behind a reverse proxy - same-origin rewrites, CORS, and CSRF cookie parity had to line up.
  • A TypeScript 7 auto-install broke next build (Next.js 16 incompatibility). We pinned TypeScript 5.9.3 and set outputFileTracingRoot to make builds reproducible.

Accomplishments that we're proud of

  • The full demo runs end-to-end with zero provider keys.
  • Provenance is a product feature, not a footnote: every file is SHA-256 verified with a manifest.
  • Version comparison is a first-class screen.
  • The generated assets are drawn in the same patent language as the UI itself, on-world from frame one.

What we learned

  • Mock-first pipelines are the right way to build products. The demo never depends on a live provider, and real providers slot in behind a stable contract instead of rewriting the app around them.
  • Security defaults (sessions, CSRF, rate limits) are cheap to add early and painful to retrofit.

What's next for Slate

  • Live providers behind the existing pipeline contract - image models, TTS, and real storyboard generation.
  • Backblaze B2 as the durable archive layer with object-path transparency in the UI.
  • Multi-user review workflows with comments and approval gates.

Built With

Share this project:

Updates