StoryXen

StoryXen is production planning software for independent film teams. I built it for Stackably end to end — the app, the AI pipeline, the marketing site. One person, every module.

The app is at app.storyxen.com. Marketing site at storyxen.com.

It started life as FilmForge. Mid-build the client rebranded. I handled the rename across the codebase, every config file, the database, and the deployed environments without taking the product offline.

How the app works

Each module feeds the next. A scene change flows into the schedule, which moves the budget, which regenerates the call sheets. Nothing is decoupled.

Script breakdown

Upload a script and the AI pipeline pulls every production element — characters, extras, props, locations, time of day — out of every scene. Extraction runs in batches sized to balance throughput and context: five or six scenes per call, capped at fifty thousand characters, ninety seconds per batch. If the primary provider returns empty or invalid JSON, the chain falls back to a second provider, then a third, then to a per-scene retry. Output gets a separate validation pass to catch hallucinated entries and merge near-duplicates.

Character names go through a fuzzy dedup pass. Scripts that refer to the same person three different ways collapse to one entry without losing the underlying mentions. Results stream to the frontend in real time as each batch comes in. Every element is color-coded inline on the script with a sidebar that jumps to every occurrence.

Uploads dedupe by content hash. If two users upload the same script — common when a producer and a line producer are on the same project — the second upload short-circuits to the cached result. A distributed lock keeps the first run from being repeated under load. If the lock holder dies before producing a result, waiting workers fall back to running it themselves with a timeout.

Storyboarding

Each scene has a frame strip. Generate AI storyboard images, upload reference shots, edit per-frame details — camera angle, lighting, shot type. The prompt builder reads from the breakdown so frames inherit context: the right characters, the right location, the right time of day. Failed generations mark the frame as failed instead of disappearing, so a retry button is always there. There's a Playground for manual prompts when you want something the pipeline wouldn't produce on its own. Frames sync across tabs without a refresh.

Scheduling

Drag-and-drop shooting schedule built from the breakdown. Scenes can run across multiple days; continuation labels keep schedules and call sheets in sync. The Day-Out-of-Days grid tracks every character across the calendar. A rules engine checks union turnaround, holidays, and overlap, and fires cascade notifications when a date change breaks something downstream.

Rapid drags used to collide on day-number assignment. I rewrote the mutation to read the current max at write time, retry on conflict, and resolve from fresh state — so a producer dragging fast doesn't see a 500 and lose work. Drag intent is read from the source: pulling from the sidebar duplicates a scene onto a new day, dragging across days moves the existing instance. Multi-day scenes share an entity but each day is its own assignment, so conflict detection keys off the assignment, not the scene.

Updates apply optimistically. The local view jumps the moment you let go; the server reconciles in the background, and any rejection rolls the UI back with a toast.

Budgeting

Line items auto-populate from breakdown elements. Above-the-line categories split into Story/Rights, Producers, Director, Cast/Talent. A cross-department cost allocator spreads shared costs — cast travel, location days — across the elements that benefit from them. Day counts pull live from the schedule, so the budget moves with it. PDF export renders server-side. Everything autosaves on blur.

Call sheets

Per-day call sheets generated from the schedule. Multiple production teams supported, each with its own scene assignments and conflict detection. Call times stay in sync between shooting days and call-sheet days in both directions: editing in one updates the other and warns on collisions across teams. Weather and talent overrides handle day-of changes without touching the schedule. Sheets export to PDF and send to cast and crew with a delivery log. Bounces and complaints come back in over a webhook and atomically flag the affected recipient so the system stops retrying.

Characters and crew

Character profiles with scene assignments and availability. Crew roster with avatar generation and profile selection. Talent assigned directly to budget line items from the roster.

The marketing site

Separate codebase. Cinematic dark theme: slate base, restrained motion, ambient radial glows behind the cards, a faint grain overlay so the gradients don't feel synthetic. Seven sections walk a director through the funnel without rushing it.

Hero with a primary CTA and a secondary sales-call link. A short demo video. Four feature cards on an asymmetric grid where the lead card is wider — the eye lands on it before the others. Six service cards covering each module of the app, with one gated as Coming Soon to telegraph roadmap without overselling. A four-step workflow with a product GIF. Testimonials with role diversity — director, line producer, investor, exec producer — anchored by an IMDb-verified credit. A final CTA.

Each module owns a hue. Script in cyan, scheduling in violet, budget in emerald, compliance in indigo, the gated one in rose. Same colors follow each module across the marketing site so the labels aren't load-bearing — you start to read by hue. Copy is problem-first and avoids hype: "stop stitching together breakdowns, budgets, and schedules by hand" instead of revolutionary-this, AI-that.

Under the hood

Modular backend, reactive frontend, a real-time data layer pushing changes between clients without polling. The AI layer runs through a graceful-degradation chain — primary, two fallbacks, per-scene retry — with a separate validation pass on every merged result. Long jobs stream progress over a persistent connection. PDF generation runs headless in containers. Email goes through a transactional provider with delivery, bounce, and complaint tracking.

Billing supports monthly and annual plans with a 20% annual discount and seven-day trials. Webhook handling holds up across two price ladders, with idempotent updates and dead-letter logging when something arrives twice or out of order.

Auth uses signed tokens. Project-level role checks fire on every endpoint that touches a project — script breakdown, storyboard, schedule, budget, call sheets — and admin-only routes are gated by ID. Stuck jobs get a sweep on server start: anything still in "processing" gets failed with a structured code so the frontend can prompt a retry rather than spinning forever. Logs are structured. Errors and product analytics flow into two separate observability layers.

Tests run on every push: unit, integration, end-to-end. Linting is enforced in CI on both halves of the codebase.

Scope

Roughly 450 commits over five months. Counting the app, marketing site, generated types, schemas, and tests, the codebase clears 700,000 lines. More than fifteen distinct user-facing screens. A multi-module SaaS with its own marketing site, full test coverage, a CI pipeline, observability, and billing. Every spec, schema, and component mine.