Version Control for Creative Work

Today, I want to tackle a topic that’s crucial for anyone creating digital work: file management. It might not be the most thrilling subject, but it’s incredibly important. If you’ve ever found yourself lost in a maze of poorly named files or had a hard time finding an old version of a project, you know it can be frustrating. You’ve probably thought, “There has to be a better way!”

So, is there a better way to manage our files? A system that keeps everything organized, tracks changes, and allows us to experiment with different ideas without losing our original work? That’s what I’m going to explore in this post.

For those of you who want to dive deeper into this topic, I’ve created a detailed PDF guide on version control for creative projects. it’s linked at the end of the post.

Now, let’s dive in!

The Trouble with “Final_Final”

We’ve all been there. You’re working on a project, and you save your progress as “final.psd”. Then, you make a few more tweaks and save the new version as “final_final.psd”. A few more changes, and you end up with “real_final.psd”, and before you know it, you’re staring at a file named “real_real_final_for_real.psd”. It might seem like a funny quirk of the creative process, but it’s a symptom of a larger issue: a lack of effective file management.

This approach to saving files is problematic for several reasons:

1. Confusion: With multiple files all claiming to be the “final” version, it’s easy to lose track of which file is truly the latest. This can lead to confusion and wasted time as you open multiple files trying to find the right one.
2. Lack of Version History: When you save all your changes under the “final” banner, you lose the ability to track the progression of your work. If you want to go back to an earlier version or see what changes were made when, you’re out of luck.
3. Collaboration Challenges: If you’re working with a team, the “final_final” approach can lead to miscommunication and duplicated work. Without a clear system in place, team members might work on outdated versions or overwrite each other’s changes.
4. File Loss: In the worst-case scenario, poor file management can lead to lost files. If you’re not sure which file is the most current, you might accidentally delete the wrong one.

These issues can cause frustration, slow down your workflow, and even impact the quality of your work. It’s clear that we need a better way to manage our files and keep track of changes.

Enter Version Control

This is where version control comes in. If you’re not familiar with the term, don’t worry – it’s a concept that comes from the world of software development, but it’s incredibly useful in many other fields, including digital art and design.

You can think of version control like a supercharged ‘Save’ button. Usually, when you save a file, you just replace the old version with the new one. But with version control, every time you hit save, it creates a new ‘version’ of your file. This means you can go back and see your project at any stage. It’s like having a time machine for your work!

But there’s more to version control than just saving different versions. It also helps keep things tidy. With a version control system, all your files are in one place, neatly organized and easy to find. No more searching high and low for that one file you saved somewhere in a hurry.

A Better Way to Organize

One of the biggest advantages of using a version control system is how it helps with organization. But before we dive into that, let’s talk about something that goes hand-in-hand with version control: a good folder structure.

When you’re working on a project, you’re likely creating and using a bunch of different files. These could be design files, reference images, notes, and so on. Normally, you might save these files wherever you find space, and before you know it, you’ve got important files scattered all over your computer. Sound familiar?

To avoid this, we start by creating a specific folder for each project on your computer. Think of this folder as your project’s home base. It’s where all the files related to that project live. This way, instead of having files scattered across different locations, everything you need is in one place.

But we don’t stop there. Inside the project’s main folder, we create more folders, each one for a specific type of file. For example, you might have separate folders for models, renders, videos, photos, assets, documents, notes, and references. This makes it even easier to find what you need. Looking for a model file? It’s in the ‘models’ folder. Need a reference image? Check the ‘references’ folder.

Inside these folders, there are sub-folders and files, all neatly organized and named in a way that makes sense. This means no more guessing where you saved a file or what you named it. Everything is in its place, easy to find and ready to use. It’s like having a super organized digital workspace for each project.

Now, it’s important to note that while this folder structure is not technically part of the version control system, it’s a key part of a good version control strategy. The folder structure helps keep your files organized, while the version control system helps you track changes and manage different versions of those files. They work together to make your life a whole lot easier!

Keeping Track of Changes

Now that we’ve got our files neatly organized, let’s talk about one of the main features of a version control system: tracking changes.

When you’re working on a project, you’re probably making changes all the time. Maybe you’re tweaking a design, adding new elements, or experimenting with different colors. With a traditional ‘Save’ button, every time you save your changes, you overwrite the old file. But what if you want to go back to an earlier version? Or what if you want to see what changes you made a week ago?

This is where version control comes in. With a version control system, every time you save your changes, it creates a new ‘version’ of your file. But how do you tell these versions apart? This is where we introduce the concept of semantic versioning.

Semantic versioning is a system for giving each version of your file a unique number. This number usually has three parts: the major version, the minor version, and the patch.

In the context of creative work, you might think of it like this:

1. Major version: This changes when you make significant changes to your project that fundamentally alter its nature. For example, if you’re working on a design and you decide to change the overall layout or color scheme, or if you’re writing a story and you change the plot, that would be a major version change. It’s about changes that transform the project in a big way. This number is the one that changes the least.
2. Minor version: This changes when you add new elements or features to your project, but without changing its overall nature. For example, if you add a new character to a scene, a new section to a design, or a new chapter to a story, that would be a minor version change. It’s about additions that enhance the project but don’t fundamentally change it.
3. Patch: This changes when you make small tweaks or fixes. For example, if you adjust the lighting in a scene, fix a typo in a document, or correct a color in a design, that would be a patch change. It’s about small adjustments that improve the project without adding new elements or making big changes.

Typically, you’ll find that your patch and minor versions increase quite frequently as you make small tweaks and add new elements to your project. The major version, on the other hand, doesn’t increase as often. That’s because major changes that fundamentally alter the nature of your project don’t happen every day. So don’t worry if you see your minor and patch numbers going up a lot – it’s a sign of progress and refinement!

So, with a version control system and semantic versioning, you can go back and see exactly what your project looked like at any point in time. It’s like having a detailed history of your project at your fingertips.

But the benefits of tracking changes don’t stop there. It also makes it easier to collaborate with others. Everyone can see what changes have been made, who made them, and when. This makes it easier to work together and keeps everyone on the same page. Plus, it provides a clear record of the project’s evolution, which can be a valuable resource for future projects. You can see what worked, what didn’t, and how your ideas developed over time.

Using a version control system with semantic versioning is about more than just keeping track of changes. It’s about making your creative process more organized, more collaborative, and more insightful.

Exploring Different Paths

One of the most exciting aspects of creative work is the ability to explore different ideas. Maybe you want to try out a new color scheme, experiment with a different layout, or introduce a new character. But often, we hesitate to try something new because we’re afraid of losing our current work. With a traditional ‘Save’ button, once you save your changes, there’s no going back.

This is another area where version control shines. Because it saves a new version of your file every time you make changes, you’re free to experiment as much as you want. You can try out a new idea, see how it looks, and if you don’t like it, you can simply go back to an earlier version. It’s like having a safety net for your creativity.

But version control doesn’t just let you experiment freely, it also allows you to explore different ideas in a structured way through a feature called ‘branching’. Think of each branch as a separate workspace for your project. You can create a new branch whenever you want to try out a different idea, and it won’t affect your main project. In our version control system, we use letters to label different branches. For example, the main project might be labeled with an ‘M’, which stands for ‘Master’, while different branches might be labeled with ‘A’, ‘B’, ‘C’, and so on. This makes it easy to tell which version of your project belongs to which branch. So, if you’re working on a new idea in branch ‘A’, your version might be labeled as 1.0.0A.

You can choose whatever naming convention you want, as long as you’re consistent about it in your projects. for example, you could instead of letters use a word or a few words to be more descriptive.

Once you’re happy with the changes you’ve made in a branch, you can bring those changes back into your main project. This is called ‘merging’. Merging is the process of incorporating the changes you’ve made in a branch into your main project. The specifics of how you merge will depend on the type of work you’re doing, but the key idea is that you’re combining your new ideas with your existing work.

You could also make the branch into it’s own different project, or abandon it if the idea didn’t work as well as you expected.

In the end, branching and merging give you the freedom to experiment with different ideas without worrying about messing up your main project. It’s a powerful tool that can make your creative process more flexible and dynamic.

Absolutely, let’s revise the entire section to improve the flow while keeping the content intact:

Remembering the Past

In the creative process, it’s common to look back at an old project and wonder, “What was I thinking when I made this change?” Or perhaps you’ve wanted to revisit an old idea, but you can’t remember exactly how you implemented it. This is where version control comes to the rescue.

With a version control system, every change you make to your project is recorded. This means you can go back and see exactly what your project looked like at any point in time. It’s like having a detailed history of your project at your fingertips.

But it’s not just about being able to see old versions of your project. It’s also about understanding why you made certain changes. That’s why, in our version control system, every time you save a new version, you also write a short message describing what changes you made and why. These messages are saved along with the versions, creating a log of your project’s history.

Here’s an example of how a series of log entries might look:

Version: 1.0.0M
User: Alice
Changes: Initial project setup.
Reason: Starting the project.

Version: 1.1.0M
User: Alice
Changes: Added a new character to the scene.
Reason: Wanted to create more dynamic interaction.

When Bob decides to experiment with a different color scheme, he creates a new branch ‘A’ and starts a separate log:

Version: 1.1.0A
User: Bob
Changes: Created a new branch to experiment with a different color scheme.
Reason: Exploring new visual ideas.

Version: 1.1.1A
User: Bob
Changes: Adjusted the color scheme based on feedback.
Reason: Improving the visual appeal.

These logs are more than just a list of changes. They form a narrative of your project’s evolution, capturing your thoughts and decisions at each stage. Reading through the log can provide valuable insights, helping you understand your past decisions, track your progress, and even provide inspiration for future projects.

In a collaborative setting, these logs become even more valuable. They allow team members to understand what changes have been made, who made them, and why. This transparency helps keep everyone on the same page and facilitates effective collaboration.

For larger teams, it can be beneficial to have a dedicated person, such as a project manager or lead designer, who manages the version control system. This person would handle tasks like merging branches, resolving conflicts, and maintaining the logs. This ensures that the version control system is used consistently and effectively across the team, and that updates to the Master version meet the expected quality standards.

The branching feature of version control is a game-changer for collaborative work. It allows each team member to work independently on their own ideas without affecting the main project. Once they’re happy with their changes, they can request for their branch to be merged into the main project. This way, everyone can contribute their ideas while maintaining a coherent and organized project structure.

Wrapping Up

So, there you have it – a practical, yet powerful, version control system for your creative projects. We’ve covered the basics of version control, from organizing your files and naming your versions, to branching and merging, and even maintaining a log of your project’s history.

With this system, you can say goodbye to the chaos of “final_final” files and embrace a more organized, efficient, and collaborative way of working. You’ll have a clear record of your project’s evolution, and you’ll be able to experiment with new ideas without fear of losing your original work.

I hope this post has helped demystify the concept of version control and shown you how it can be applied to creative projects. Remember, the goal here isn’t to add more complexity to your work, but to make your creative process smoother and more manageable.

What I spoke about here are only suggestions, you can and should adapt the system to your needs. I’m not an expert on the topic, I just merged what I know from software development and project management into something that kinda works for me. I still update my system often, and there are edge cases where I just can’t organize neatly so sometimes projects are still messy, but I do what I can to mantain order.

For those of you who want to dive deeper into this topic, I’ve created a way more detailed PDF guide on version control for creative projects. it delves a lot deeper into how to organize your folders and how to name your files. You can download it here: