Is there a tool that creates product videos automatically when you push code to production?

Somebody on your team has typed this question into Google, because we see it in our search console every week: is there a tool that creates product videos automatically when we push code to production?The people asking are usually developers or founders who ship several times a week and have noticed that nobody outside engineering knows what changed. Release notes go unread. Somebody records a Loom on Friday if they remember. The work is invisible.

So here is a straight answer, with the trade-offs each approach carries, and a walkthrough of the one we build.

The three ways to generate a video from a code change

1. Record the running app in CI

End-to-end test runners such as Playwright and Cypress can record video while they drive a browser. Point a script at your staging URL, click through the new feature, save the MP4 as a build artefact. It is free and it shows the real running product.

The catch is that somebody has to write and maintain the click-through for every feature, the recording has no narration and no explanation, and the output looks like what it is: a test run. It is a great way to catch regressions and a poor way to announce a feature.

2. Let an AI presenter read a summary

Avatar and text-to-video tools (Synthesia, HeyGen and similar) will turn a paragraph into a presenter talking on camera. You can wire them to a webhook that fires on merge and feed them the PR description. You get a polished human-looking video in minutes.

What you do not get is your product. The presenter can describe the new export button; it cannot show it, unless you also supply footage, which puts you back at option one. For a marketing teaser this can be fine. For "here is what we shipped", viewers want to see the thing.

3. Render the UI from the code itself

This is the approach PushPlay takes and, as far as we know, the only one that shows the real interface without anyone recording it. The generator reads the pull request, finds the components that changed, and renders them as animated panels using your project's real colours, fonts and layout. An AI model writes a short script from the diff and the PR description, a voice reads it, and a motion template turns the panels and narration into a 60 to 90 second video.

Because it works from source, it needs no staging environment, no test account and no screen recording. It also has a real limitation: it renders what it can reconstruct from the code. The result looks like your product, uses your design system, and demonstrates the feature, but it is a motion rendering of your UI, not a pixel-perfect capture of production. For changelog and feature-announcement videos that is what you want; for a compliance walkthrough of exact production screens it is not.

What a generated video actually contains

A PushPlay changelog video for a typical PR runs like this:

• Intro (3 to 5 seconds): project name and logo, the feature headline, in your brand colours.
• One scene per user-facing change (15 to 25 seconds each): an animated panel of the relevant screen inside a browser or phone frame, with the voice explaining what it does and why it matters. The scene length is derived from the recorded narration, not the other way round, so nothing feels rushed or padded.
• End card: call to action, URL, and on agency plans the agency's own branding.

Backend-only changes get a narrated explainer instead of a UI panel. Changes that are purely refactors get filtered out during analysis, because nobody wants a video about renaming a folder.

Setting it up: from repository to first video

1. Sign in with GitHub. Sign-in asks for your identity only. It cannot read any repository.
2. Add a repository. For a public repository, paste its URL. For a private one, install the PushPlay GitHub App and tick exactly the repositories it may read; GitHub shows you the permissions (read access to code, write access to pull requests so it can comment with the video link).
3. Let it index. PushPlay walks the repository once, extracts design tokens (colours, fonts, radius) and learns which components make up which screens. For a large Next.js app this takes one to two minutes.
4. Pick a merged pull request, or any set of changes between two commits. PushPlay groups the diff into user-facing features and lets you untick the ones not worth a scene.
5. Generate. Script, voice, UI panels and render happen in one run, four to six minutes end to end. You get an MP4, a shareable page, and a comment on the PR.
6. Turn on auto-generate (Pro plan) so every merged PR produces a video without anyone opening the dashboard.

Where it fits, and where it does not

Automatic videos are a good fit when you ship often to people who do not read pull requests: clients of an agency, users of a SaaS product, a sales team that needs to know what changed, stakeholders who skim. They are a poor fit when the change is invisible (infrastructure, performance) or when the audience wants a long-form tutorial rather than a 90 second announcement.

If you are choosing between approaches: option one when you already have end-to-end tests and want raw footage; option two when you need a human face and have footage to go with it; option three when you want the product itself on screen without recording anything. Our comparison of AI video generators for feature announcements goes through the individual tools.