DaVinci Resolve Version Control: Timelines, Backups and Client Versions
How I run DaVinci Resolve version control in two layers: duplicated timelines and backups inside Resolve, and numbered client versions so notes never land on the wrong round.
A DaVinci Resolve timeline mix-up derailed a review call with a client from my video-editing agency, where I was screen sharing and walking through what I believed was round three of a brand film. About two minutes in, the client stopped me and asked where the new music cue was, right, the one they had asked for the week before, and I was really really confused because I had watched our editor put that cue in myself.
That call is basically where my whole approach to DaVinci Resolve version control comes from. The export had come out of the wrong timeline, the round two timeline still sitting in the media pool with almost the same name, so the client was watching old work and giving fresh notes on it. It cost us a full day of untangling which note belonged to which cut, and that's the day I started treating versions as two layers, the ones you keep inside Resolve and the ones your client actually sees.
So this post is how I run both layers now, inside Resolve with duplicated timelines, backups and sane names, and outside it with numbered client versions in PlayPause, so every note has exactly one cut to land on.
What DaVinci Resolve version control covers and what it does not
If you come from software, version control means every change is recorded and you can walk back to any point in history. To be very honest, Resolve does not work like that, right, there is no commit log sitting quietly under your timeline. What it gives you instead is a set of separate tools that behave a bit like version control if you use them with discipline, so duplicated timelines, local grade versions on the Color page, Live Save, scheduled project backups, exported project files, full archives and so on.
What none of those tools do is talk to your client, so Resolve has no idea which timeline you exported on Tuesday or which round a note about the logo was written against, and that gap is exactly where my brand film call fell apart, right. Git-style apps that run alongside Resolve keep a nice history for the editor, but the client never sees any of it, so they don't touch the problem I actually had.
So I split the whole thing into two layers. The first lives inside Resolve and protects your work, so you can always get back to any round you delivered, and the second lives in the review tool and protects the conversation, so every note sits on the version it was written against. If you learned the Edit and Color pages from Blackmagic's own DaVinci Resolve training material, think of this as the admin layer nobody teaches until a round goes wrong.
one Resolve timeline edited and exported again every round, so nobody knows which cut the client saw
every delivered timeline becomes its own numbered version on one card, with notes pinned to it
Duplicating timelines for each review round
The single most useful habit I have in Resolve is duplicating the timeline the moment a round is exported, right, before anyone touches it again. You right-click the timeline in the media pool, choose Duplicate Timeline and rename the copy straight away, because otherwise within a week you'll have four copies and no clue which one went to the client.
I keep the naming deliberately boring, with the project code, the round and the client version it will become, so for instance BRND_R02_MV2 is the round two edit that went out as the second version on the review card, and BRND_R03_MV3 is the one I'm working in now. Old round timelines go into a bin called Delivered Rounds, and the only timeline in the Current bin is the one being edited, so a tired editor late at night can't grab the wrong one by accident.
The catch here is grades, and this is the one that bites colorists, right. On remote grades, the grade follows the source clip across every timeline in the project, so a color change you make for round three quietly shows up in your round two timeline as well. I keep client projects on local grades so each duplicated timeline carries its own grade, and I use local versions on the Color page only for alternatives inside a round, like a warmer and a cooler take, never as a stand-in for the rounds themselves.
This kind of duplicate timeline versioning also makes batch exports calmer, and if you are rendering several DaVinci Resolve timeline versions for one review, I wrote up how I render multiple timelines into one link, which pairs really well with this naming.
Project backups and archives that save you when a round goes wrong
Duplicated timelines protect you from yourself, but they all live inside the same project, so if the project gets corrupted every timeline goes down together, right. That's where Resolve project backups come in, and I'm pretty sure most editors I talk to have never opened those settings even once.
In Preferences, under User and then Project Save and Load, switch on Live Save so every change is written as you work, and switch on Project Backups, where I run one every 10 minutes and keep hourly ones for 8 hours and daily ones for a week. Point the backup location at a drive other than the one your database lives on, because a backup on the same dying disk is basically a second copy of the same problem. When a round goes wrong, you right-click the project in the Project Manager, open its backups, load the one from before things broke and you're working again in minutes.
On top of the automatic stuff, I export a project file by hand every time a round is delivered, named exactly like the timeline, so BRND_R02_MV2 sits in the job folder right next to the video the client saw. It carries no media and it's the fastest way to hand someone the exact state of a delivered round. When the job closes I make a full project archive with the media inside, and that goes to cold storage along with the final masters.
- Live Save switched on in Preferences
- Project Backups running on a schedule
- Backups pointed at a separate drive
- A project file exported at every delivered round
- A full archive made when the job closes
If more than one person works in the same project on a shared database, backups matter even more, and it's worth reading how I avoid project lock conflicts when an editor and a colorist share a timeline, because a lot of version problems start as two people saving over each other.
Mapping each Resolve timeline to one client version
This next rule is the bridge between the two layers, and it's the one that would have saved my brand film call. One Resolve timeline becomes exactly one client version, and once a timeline has been exported and sent, nobody exports from it again, so if the client wants a change you duplicate, rename, make the change in the new timeline and export that, and the file and the timeline always match one to one, right.
PlayPause only has a native panel for Premiere Pro, so with Resolve the loop is manual and simple. You export from the timeline, upload the file, the client reviews in the browser, and then you take the frame-accurate notes back into your edit yourself. The client opens one link with no account and no install, every comment is pinned to the exact frame, and they can draw on the frame when words aren't enough. I walked through getting timestamped notes into Resolve in a separate post, and the page on PlayPause for DaVinci Resolve covers the setup side.
The part people skip is uploading the new export onto the same card instead of as a fresh file. When round two goes onto the card that already holds round one, it stacks on top as the next version with the older one still underneath, whereas a separate upload gives you a second card with its own link and its own comment thread, and that is exactly how notes end up on the wrong round, you see what I mean here.
Frame-accurate note, everyone sees the exact same thing.
Numbering client versions so notes land on the right round
Version stacks in PlayPause, which you get on Creator and up, number every upload on a card as MV1, MV2, MV3, MV4. That number is what I want the client thinking in, right, because it's short, it's on screen and it can't be misread. It's also why my timeline names carry it, so when a client says the fade on MV3 is too slow, I know the note belongs to BRND_R03_MV3 without a single follow-up question.
On a typical brand film it runs like this. BRND_R01_MV1 goes out, the client leaves notes on MV1, I duplicate that timeline into BRND_R02_MV2, work through the notes and upload the export onto the same card so it becomes MV2, and the R01 timeline moves into Delivered Rounds for good. If the client on MV3 says they preferred the ending from MV1, I open MV1 in the stack, find the frame their old comment sits on, and the timeline name tells me exactly where to copy that ending from. Does that make sense, right, the MV number is basically the key that connects a note in the browser to a timeline in your media pool, and that's what makes client review versions trustworthy.
Then I use custom statuses, which every plan has, to mark where each version stands, so a card might say Needs Changes while MV2 is out, move to In Progress while we build MV3, and flip to Approved once the client signs off. At the end of the day the status tells your team which MV ships, and it stops you delivering the second last version just because it was the file open on someone's desktop. The who-watched analytics help too, since you can see who opened the link and when before you start chasing notes.
Every note deserves exactly one timeline to land on, and the client should never have to guess which cut they are watching.
If you run a bigger shop with a supervisor juggling several colorists, the same numbering keeps grade handoffs across time zones sane, and it's the backbone of how we think about review for post-production houses running lots of parallel jobs.
Comparing versions side by side before the client does
Before any new version goes out, I want to see it next to the previous one, right, because the fastest way to lose a client's trust is them finding a note you missed. On the Agency plan PlayPause has side-by-side version compare, so you put MV2 and MV3 next to each other and walk through the MV2 notes one by one, checking that each fix is really there and that nothing else moved.
Resolve helps on its own side as well, since newer versions let you compare a timeline in the media pool against the current one and flag the edit differences. I use that for the cut, and the review compare for what the client will actually see after export, so the grade, the titles and the mix. Trust me on any level, doing this ten-minute check yourself is very very much cheaper than a client doing it for you live on a call.
There's a longer page on side-by-side version compare written for documentary editors, and my guide to video version control software covers choosing a tool. I compared flat workspace pricing against per-user tools in my Frame.io alternative for Resolve post, and if you're coming over from Premiere, my notes on switching from Premiere Pro to Resolve cover what changes in the review loop.
Frequently asked questions
Does DaVinci Resolve have built-in version control?
Not in the software sense, right, since there's no history log you can scroll back through. Still, duplicated timelines, local grade versions, Live Save, scheduled Project Backups and exported project files together cover most of what you need inside the app. What Resolve doesn't cover is the client side, meaning which export the client watched and which notes belong to it, and that's the layer I handle in the review tool with numbered versions.
How many timeline versions should I keep in one project?
I keep every round the client actually saw, for instance R01 to R04 on a typical brand film, sitting in their own bin where nobody edits them, and I delete scratch experiments that never left the building. If the project gets heavy, the project file I export at each round means I can safely clear old timelines later and still rebuild any delivered state in a couple of minutes.
Is there a PlayPause panel inside DaVinci Resolve?
No, and I'd rather be straight about that. PlayPause has a panel for Premiere Pro, but for Resolve the loop is export, upload, review in the browser, then bring the frame-accurate notes back into your timeline yourself. In practice the extra work is one export and one upload per round, and because the version number sits in your timeline name, you always know which timeline a note belongs to.
Which plan do I need for version stacks and version compare?
Version stacks start on Creator at $9 a month, which is enough if you just need MV1, MV2 and so on stacked on one card. Side-by-side version compare comes with Agency at $19 a month, which also adds AI transcription and Playbooks. Both are flat per workspace rather than per member, and every plan comes with a 7-day free trial.
Setting up both layers on your next project
If you do one thing after reading this, duplicate and rename your current timeline before the next export and upload that export onto the existing card, right, and you've already fixed the mistake that wrecked my brand film call. When you want the client side sorted properly, have a look at PlayPause pricing, pick the plan that fits your team, and run your next Resolve round through it on the 7-day free trial.
So yeah. That's my way of saying it.
Saumyajit co-founded PlayPause after years watching review and approval quietly eat creative teams' deadlines. He writes about the workflow side of video, feedback, versioning, and getting to a clean sign-off.
Related resources
Keep reading
Bring your team into one review space
Centralize feedback, lock approvals, and deliver faster, start free today.
Sign Up for Free