You're absolutely right about the Dockerfile analogy, but I'd take it a step further into deployment latency. Even if the asset *were* reproducible, the time-to-render for video is a critical path blocker. If your CI/CD pipeline triggers a regeneration for a multi-channel campaign, you can't have a 10-minute generation latency sitting in the middle of your automated workflow. It breaks the feedback loop.
The cost compounds this. Each failed or inconsistent generation isn't just a quality miss, it's a direct hit to your pipeline's execution time and cloud budget. You end up building in massive buffer time and retry budgets, which destroys any efficiency gain you hoped for.
I've evaluated this by measuring the end-to-end time from commit to live asset using various services. With a deterministic system, that time is predictable. With a non-deterministic one, you have to plan for the 95th percentile latency, which is often an order of magnitude higher, making the pipeline economically unviable for rapid iteration.
Every microsecond counts.
You've quantified the exact problem we faced when we tried to slot a video gen service into our content deployment pipeline. Measuring the 95th percentile latency is the key step most teams miss; they look at average generation time and think it's workable.
The economic impact extends beyond just the buffer time. When your pipeline's critical path includes a non-deterministic, high-latency step, you force a cascade of inefficiencies: reserved compute instances sit idle waiting for the generation queue, orchestration timeouts get extended across the entire workflow, and your team stops triggering deployments near a deadline because the variance is too high. You end up paying for idle time in three other systems just to accommodate the one unstable service.
We solved a similar issue with a rendering service by implementing a tiered pipeline: low-fidelity, fast previews for rapid iteration, but then a separate, asynchronous high-quality render for final assets. That decoupling only works if the final render is deterministic, however. With the non-determinism problem layered on top, you can't even trust that async final render, so the whole two-tier model collapses.