Reusable Editor Drafts: One Timeline, New Footage Every Week
Most recurring content is the same edit with new footage dropped in. Save the timeline once, swap the clips each week, and learn the create-vs-update rule.
Most recurring video content isn't actually new content week to week — it's the same edit wearing new footage. A weekly product spotlight, a Friday recap, a testimonial series: the intro beat, the caption look, the music bed and the pacing all stay identical, and the only thing that's supposed to change is what's actually being shown. Yet a lot of teams rebuild the whole timeline from a blank project every single time, re-picking the transition, re-setting the caption style, re-finding the music track — because nothing in their process treats the structure itself as a saved, reusable thing separate from the footage running through it.
It doesn't have to work that way. The structure can be the template. The footage can be the only variable.
What actually gets saved
Versely's cloud editor stores a finished edit as an EDL — an edit decision list, the full project state behind a timeline: the ordered clips, their trims, any text overlays, the music and voiceover tracks, and the caption settings, all captured as one object rather than scattered across a dozen separate settings. save_editor_project writes that object to a draft. get_editor_project reads it back — not a summary, the complete edl field, exactly as it was left, ready for the agent to read and modify before the next render.
That distinction matters more than it sounds like it should. A draft isn't a rendered video sitting in storage waiting to be reused — it's the recipe for one, which is precisely why it's reusable in the first place. You can't swap the footage inside a finished MP4. You can swap it inside an EDL, because the EDL is still just structured references to clips, not baked pixels.
The one rule that keeps a template from quietly forking itself
There's a single piece of API behavior worth understanding before you build a weekly habit around this, because getting it backwards is how a "template" quietly turns into a pile of near-duplicate drafts instead of one clean, evolving one. Saving a draft is the same call either way — save_editor_project — and the only thing that decides create versus update is whether you pass an id:
- Omit the
id, and a brand-new draft is created. This is what you want the very first time you build the structure, or any time you deliberately want to fork a new variant without touching the original. - Pass the
id, and that specific draft is updated in place. This is what you want every single week after the first — load the template, swap the footage, save back over the same draft, so "this week's version" and "the template" are the same object rather than two objects drifting apart.
The failure mode in each direction is different and worth naming, because they don't look like errors when they happen. Omit the id when you meant to update, and you get a brand-new draft sitting next to the one you actually wanted to change — your "real" template is now stale, and you won't notice until you load the wrong one next week. Pass the same id when you actually wanted a one-off variant kept separately, and you've silently overwritten something you might have wanted to keep. Neither throws an error. Both are just the tool doing exactly what you told it, which is exactly why it's worth being deliberate about which one you mean every time you save.
Finding the right draft before you load the whole thing
Once you've got more than one or two saved templates, list_editor_projects is the cheap way to find the one you want: it returns metadata only — id, title, duration, clip count, thumbnail, and when it was last updated — newest first, without pulling the full timeline for every draft just to show you a list. That matters because get_editor_project returns the entire edl, which is the right call once you know which draft you're after, but a wasteful one to run against every saved project just to remember which is which. List first, by title and thumbnail. Load second, once you've actually picked one.
What should stay fixed, and what's actually the variable
Treating a timeline as a template means being deliberate about which parts of the EDL are the structure and which part is the slot the new footage drops into. In practice, for most recurring formats:
- Fixed: the intro/outro clips, the caption font and style, the music bed, the transition style, the overall pacing and clip count.
- Variable: the footage in the middle — the actual product shot, the actual testimonial clip, the actual recap footage for that specific week.
Naming that split explicitly, even just to yourself, is what turns "I'll rebuild something similar" into "I'll load the template and change exactly one thing." It's also what keeps a series looking like a series — consistent enough to be recognizable, varied enough in what it's actually showing that it doesn't collapse into batch generation that reads as templated rather than as a healthy recurring format.
Not to be confused with a saved scene workflow
Versely has a second, genuinely different "save it and reuse it" system worth distinguishing clearly: saved video workflows, which store a full scene-based generation recipe — characters, style, scenes — and regenerate fresh AI footage on each run. An editor draft is not that. It's an assembled timeline built from footage you already have (generated, uploaded, or both), not a recipe for generating new footage from scratch. If the weekly variable is "new AI-generated scenes with the same characters," you want a saved workflow. If the weekly variable is "new real or already-generated footage dropped into the same assembled structure," you want an editor draft. Both are reusable. They're reusable in different layers of the pipeline.
Versely walkthrough: load, swap, save, render
The full loop, in the order it actually runs:
"Load my 'Weekly Product Reel' editor draft, swap the middle clip for this week's product footage, save it, and render the result."
Under the hood: list_editor_projects (or a direct ask, if you already know the title) finds the draft by its metadata. get_editor_project loads the full edl — the intro clip, the caption style, the music bed, and the placeholder middle clip from last week. The agent swaps the URL for that middle clip to this week's footage and leaves everything else in the EDL untouched. save_editor_project writes it back with the same id, so the template updates in place rather than forking. Finally, edit_video renders the actual video — worth previewing at a free 480p pass first while you confirm the swap looks right, then running the paid final export once it does.
That's the entire weekly routine, and after the first build, none of it involves re-deciding the transition, the font, or the music. It involves one footage swap and one render.
The takeaway
The template isn't a mental habit you have to maintain by memory — it's a saved object, and the only discipline it actually requires is remembering whether you're updating it or forking it, which comes down to one parameter. Build the structure once. Decide what's fixed and what's the variable slot. Save with the id every week after the first, so the draft evolves instead of multiplying, and swap the footage rather than rebuild the format — that's the whole difference between a recurring series that takes minutes and one that takes as long as the first episode did, every single week.