Preflight

**Check, fix, and prove your film is ready to deliver.**

Comment

Inspiration

A film can be completely finished and still fail delivery.

Festivals, distributors, and platforms publish different technical requirements for codecs, loudness, subtitles, frame rates, containers, metadata, naming, and more. Filmmakers often discover a mismatch only after submitting — when a rejection email arrives.

We built Preflight to move that check earlier.

Instead of asking a filmmaker to manually read technical specification pages and compare them against a master file, Preflight finds the destination's requirements, measures the actual film, fixes what it can safely fix, and proves what happened.

What it does

Preflight sits between “the film is finished” and “the film is delivered.”

A filmmaker can:

  1. Upload a finished master.
  2. Choose a destination — or search for a new one.
  3. Let Preflight retrieve that destination's current published requirements.
  4. Measure the actual media against those requirements.
  5. See what already passes, what Preflight can safely fix, and what genuinely needs human input.
  6. Approve safe fixes or an explicit technical conform while the original remains untouched.
  7. Have the newly prepared files independently measured again.
  8. Download the prepared package and view its proof.
  9. When every required check genuinely passes, receive a VERIFIED package and delivery room.

For destinations that are not already configured, Parallel searches for the destination's official sources at runtime. Only trusted first-party sources are allowed to create mandatory requirements; non-official pages may provide context but cannot silently become rules.

Preflight also fails closed. If a requirement is ambiguous, cannot be measured, conflicts with another source, or needs a creative mastering decision, it does not pretend the film is ready.

How we built it

The frontend is built with Next.js and TypeScript, with Firebase Authentication and resumable uploads to private Cloud Storage.

The backend uses FastAPI, PostgreSQL, Cloud Tasks, and isolated media workers on Google Cloud Run.

Media facts are measured deterministically using FFmpeg, ffprobe, EBU R128 analysis, and Pillow. Models never decide what a file contains.

For destination intelligence, Parallel discovers and extracts official specification sources. Gemini on Vertex AI turns those sources into a strict requirement schema, while trust tiering and validation happen deterministically after model output.

Repairs are planned before execution. The user approves the exact plan, the original master remains immutable, and every generated package is reopened and measured again from scratch before Preflight reports the result.

The final proof records the requirement sources, transformations, hashes, measurements, unresolved limitations, and verification state.

Challenges we faced

The hardest part was learning that passing backend tests was not enough.

During browser testing we found production issues that server-side tests could not expose, including CORS failures during real uploads, resumable-upload edge cases, and repair flows that behaved differently when driven by an actual user.

Media conversion also forced us to verify assumptions instead of trusting encoder settings. For example, asking an encoder for a bitrate does not guarantee the resulting file actually has that bitrate, so Preflight now trusts the re-measured output rather than the requested parameter.

Requirement extraction created another challenge. Published specifications are written for humans, and a model can misinterpret units or scope. We built a review path where questionable requirements can be set aside only with a recorded reason, rather than silently deleting them.

Accomplishments we're proud of

Preflight now works end-to-end against deployed services and real media.

We proved both sides of the product:

  • A package can reach VERIFIED when its required conditions are genuinely satisfied.
  • When a destination still has unresolved requirements, Preflight still produces a downloadable prepared package and proof — but clearly marks it not ready for delivery rather than creating a false green check.

We are especially proud that Preflight preserves the original film, independently revalidates every generated output, and keeps the evidence behind its decisions visible.

What we learned

The biggest lesson was that an agent should not be the source of truth for measurable facts.

Models are useful for discovering and interpreting human documentation. But whether a film is H.264, 48 kHz, -24 LUFS, or 25 fps should come from deterministic media tooling.

We also learned that trustworthy automation sometimes means refusing to automate. Preflight can perform deterministic fixes and explicitly approved technical conforms, but it will not manufacture a surround mix or silently make a creative decision just to reach 100%.

What's next for Preflight

Next we want to expand the destination library, support private specification documents for distributors whose requirements are not public, improve requirement extraction quality, and make the correction workflow even simpler for filmmakers and post-production teams.

The longer-term goal is simple:

a filmmaker should know whether a finished film is ready before the destination has to tell them it isn't.

Built With

Share this project:

Updates

Submission history