It mirrors how Git works. A branch is where you can explore changes and new ideas. When the work in a branch is ready, you compare it with the main file. Branching is especially useful on active projects. Developers don’t have to guess which design is final. Before branching, the easiest way to version like this was duplicating specific pages. When they open the file, they don’t need to guess which screens are exploratory or outdated. And when a designer requests a review, reviewers see a direct comparison between the branch and main. Reviews validate changes before they reach main. Branching only works if files stay clean and predictable. Branch naming is key to making it work in practice. For features and flows, that usually means Jira task keys with a short description. It stays demoable and handoff-ready at all times. Once a project is moving, we make most meaningful updates happen in their own branch. Our reviews are lightweight but consistent. We typically create a separate branch for each workshop or major feedback round.
Strategic branch usage and review flow
First, it keeps the main file clean. A small tweak can affect dozens of screens and flow through directly to frontend code. Once a design system is in place, any meaningful change happens in its own branch. We merge design system branches only when changes are approved and ready to be built. A feature, a flow update, a workshop outcome, or a design system change. Unmerged, abandoned branches can lead to confusion down the line. No. This is how we like to work at DECODE. If you don’t have edit access to the main file, you must request a merge from someone who does have edit access. You can request a review from anyone who has access to the main file. You can request one or more people to review and approve the changes before merging the branch to the main file.
Click Review and merge changes... Reviewers can choose to approve your branch or suggest further changes. There are three possible outcomes from a review. In review: A gray badge shows that a branch review has been requested from another user. Changes suggested: A yellow badge indicates that the reviewer needs you to make some changes before the branch is accepted. You can open the review modal to view the suggestions. Reviewers may have added feedback to individual layers or designs using comments. Approved: Your changes have been approved, but the branch has not yet been merged. When ready, you can click Merge branch in the bottom right corner of the Branch review window, which will merge the branch into the main file. Resend a review request to any reviewers. Click Send to reviewer. Branch creators can request a review from a team member or other collaborator before merging a branch. Reviewers can view all the changes included in the branch. If you only have view access to the main file, you can still review a branch. Branch reviews apply to all changes in a branch. You can use the review process to suggest changes to the branch creator. In the left sidebar of the Branch review window you can see a summary of the branch. View details of the review request in the Review request section. In the main body of the window you can view a list of components, instances, or layers that have been, , , or . If you're happy with all of the changes you can approve the branch. Select Submit to approve the branch. If there are changes you'd like the branch creator to make before merging, you can suggest changes. If there are specific changes or suggestions you'd like to make, you can also add comments to the individual designs. Add any general comments you want to make (optional). Select Submit add your review. Edit your review to make changes to your comment. Find your review in the left sidebar. You'll see a blue border around the comment to show the field is now editable. Click inside the text and make any changes as needed. If you've made a mistake or want to change your review, you can review the branch again. Press enter or click to view image in full size
Designers and the evolution of branching in Figma
Designers don’t have a natural urge to branch. It’s undoubtedly spectacular that designers can tinker around in their Figma files within a branch these days. During Sketch days, branching of a file was only possible via Abstract, and companies had to shell out an extra license fee for Abstract integration reluctantly. And practically without Abstract, design worked in a vacuum within Sketch. But those days are long gone. Figma now has strong branching capabilities for designers to manage their changes and put them up for review once they are done working on them. But Figma’s branching capabilities are not fully matured.
Branching in design tools is essentially a borrowed concept from tools like Github, where developers often branch from master before they start to work on a new feature. But to designers, branching not only allows them to work without disturbing existing work but also provides a safe space to explore and iterate without attracting judgment. Figma recently lost its Beta tag for its branching feature, and added a bunch of features like branch review and suggestions. One popular use case is for maintaining and contributing to style and component libraries. You and your team can create as many branches as you like. Within the branch, you can safely explore changes and iterations, without disrupting anything or anyone in the main file. You can add, edit, or remove individual layers, components, or entire designs.
Select Create branch... Give the branch a name. Figma will create a new branch that is an exact replica of the main file in its current state. Branches are an extension of the main file. Anyone with access to the main file can access branches. Tip! Figma will let you know if there are any updates available in the main file. You can then review any changes made in the main file and choose to apply them to your branch. It's not possible to pick and choose which changes you want to apply. When you're finished making changes in your branch, you have the option to request a review. Reviewers can preview the branch changes alongside the main file. When you're satisfied with your changes, you can review and merge your branch with the main file. View all branches in the Branches modal. You'll see three tabs for Active and Archived branches, as well as branches you created (Yours).
Note: There are a few steps involved in receiving updates and merging changes. There are a few things you can do if something doesn’t look right after a merge or update. View activity related to branching and merging in the file's version history. Everything that happened in the branch will be contained in that single checkpoint. You can only publish to a library from the main file. You can only publish to the Community from the main file. Figma will duplicate the branch and add it as a file to the existing location. Press enter or click to view image in full size
Approaches and lessons from real-world use
Designing in Figma can be challenging. One wrong move can lead to outdated design files, broken links, and confused teams. We, as designers, must keep the design up-to-date and need to think about changes and new features. Some designed features may wait a long time for development to start, which we need to consider. This is important for QA, developers, and clients. They need to see relevant designs. Any confusion can lead to misunderstandings, defects, and extra discussions. If the designs were clear and relevant, the issues could have been avoided easily. Managing versions adds another layer of complexity. In this article, I’ll share how we at Devexperts manage designs in Figma. I’ll tell you about our approach at the beginning of our project, how it evolved, and the approach we’re using now. Also, I will tell you about our use of branching in Figma and why it didn’t work for us.
Approach №1 - Designing on a single Figma page. At the start of our trading app project, we organized all designs on one Figma page. This page displayed frames for every design in each app section, such as “Order Book,” “Watchlist,” and “Order Entry.” Globally, we organized these frames into three categories: Released - implemented designs, Dev Release - designs are ready for implementation, Concept - design concepts with future improvements, not approved yet. Every time a frame with a new feature or improvement moves from “Concept” to “Dev Release,” and then to “Released.” Each frame had a link to a Jira task and a Confluence page with the requirements for each section of the app. A major downside of this approach was replacing “Order Book” with “Order Book v2” after implementation, which broke existing links to the previous design. At that time, we didn’t need to create an archive and send previous designs there. In the beginning, it wasn’t a problem yet.
Approach №2 - Designing across many Figma pages. Over time, each frame grew, and a single Figma page was no longer enough. To handle this, we decided to break it into several Figma pages, each covering a different section of the app. We renamed the categories to “Released,” “Ready for Development,” and “Drafts,” which helped to clarify their purpose. This approach worked well overall, but it had a few downsides. The main issue was that the new feature or improvement could affect many parts of the app. That’s why we had to create a different set of frames for each page/section of the app. That helped us keep everything organized, but it created some complications for tracking. Checking the new feature or improvement meant jumping between many pages. This made things more complex. Sometimes, features/improvements can be delayed for a long time, or they might be canceled. We started accumulating them in a Figma file. If many designers work on the project, they may miscommunicate or forget things over time. This can lead to the creation of new features/improvements without considering the old ones. The frames began to conflict with each other. As a result, the team struggled to understand where they could find the relevant design. Comments and statuses didn’t help. Another difficulty was component management when working on new features/improvements. Designers began creating new versions of components or detaching original components, which caused more components to appear. It also meant extra work to maintain them.
We realized our system needed improvement. We decided to simplify our design process. We wanted to have only relevant (that matched with implementation) designs in Figma. All new features/improvements were transferred to native Figma branching functionality. At that moment, we had heard about it, but we did not use it. But we started by completely redesigning our Figma file.
Approach №3 - Redesign and Figma branching. We started by reviewing our designs to ensure they matched the implementation. Then, we fixed the inconsistency. We removed outdated frames from the main file and put them in a separate archive file. We split the big frames into smaller frames, each focused on a specific action. For example, “Cancel Order” has focused only on the order cancellation process. We created a “Table of Contents” with quick links to each frame, simplifying the search process. Eventually, this helped everyone: QA, developers, and the client. They could find the right design, inspect it quickly, and not get distracted by other designs. We refused to use the categories “Released,” “Ready for Development,” and “Drafts.” We didn’t need them because we moved them into Figma branches. We had aimed to use branches for all our future updates, bug fixes, and other improvements. This, as we thought, would help us avoid having too many frames in one file. But it caused a lot of other problems.
Figma branching and the nightmare. At first, we believed Figma branching was a great idea. It seemed like a perfect way to organize our design files and keep unimplemented features separate. We moved our future improvements into Figma branches and updated the links in Jira and Confluence. If you make changes in the Figma branch, this change only applies to this branch. When you change something in the main file, Figma will notify any branches that need to apply this update. A modal window will show the comparison/conflict between the component in the main file and the same component in the branch. You need to choose which one you want to use in the branch: updated or original from the main. After a while and many Figma branches, we started to receive many requests to update from the main file. Since improvement is a never-ending process, we have to make small updates to the main file on a regular basis. And applying these small changes every time was very annoying. Soon, we encountered an unexpected issue with the components. If a designer updates a component in the branch, they might lose those updates. This can happen if someone else changes it in the main file, and the designer agrees to that update for the branch. We did this several times in our practice by mistake. Figma sometimes didn’t clearly show the difference between the original components in the main file and the updated ones in the branch. Figma shows every update from the main file, even those not connected to your new branch. Sometimes the amount of conflicts was huge. We even had a fun screenshot contest to see who could capture the biggest amounts of conflicts. Reviewing so many conflicts is unmanageable, and unintentional overwriting becomes bound to happen.
Realizing that this approach wasn’t sustainable, we decided to update our approach a bit: We receive a change request, design improvement, or new feature request. We created a Figma branch. We created a new page in that branch. We put all our updates on this page. We waited for implementation. We merged the branch back into the main file with all these changes. With this approach, we didn’t change the main file’s components. We made new components based on the main file with the prefixes v2, v3… This allowed us to keep the components for the update separate from the ones in the main. When we got updates from the main file, we simply clicked “Resolve All.” We didn’t check anything, and we didn’t have to worry about overwriting anything. Life became easier, but we still spent a lot of time applying all these updates. Sometimes, it took a few minutes every time we opened a Figma branch.
After that, we encountered another problem. The fact that features/improvements can be postponed for a long time. It’s become a problem again. If you don’t open your Figma branch for a while, you’ll miss updates from the main file. This can lead to your branch breaking and not opening due to the updates stacking up. Because of this, we often faced errors when syncing updates from the main file. After weeks of struggle, we gave up and finally admitted that branching in Figma didn’t work for us. We decided to rebuild the process once again. I need to clarify: we base this opinion on our design experience. For example, we build our design mockups from components. We have small components and large components composed of the small ones. Also, full screens are sometimes components, too. Changes in small components impact the larger components that they are a part of. In our iOS Figma file, we have 1 407 components and a total of 51 043 layers. If your system is less complex and you can quickly add features, Figma branching could be a good choice. In our case, this functionality is completely unusable.
Approach №4 - Duplicated Figma files. We decided to move away from Figma branches. At exactly the same time, we went to production, and the client decided to have versioning. One version was in production, going through QA testing and bug fixing by developers. The second version included the upcoming release with new features and updates. They shared the release roadmap, which listed all the new features that had been waiting to be released until then. It became clear that we couldn’t store designs for two different versions in a single file. Especially if we wanted to have two versions, keep the relevant links, and not confuse anyone. And we came to the following solution: Let’s assume that the Figma file version 1.0 is our main file, which matches the version in production. It has all the components, styles, colors, and fonts there. Designers fix bugs and add missed flows or extra screens to this file. QA checks it. Jira links lead to this file. This file is completely self-contained and is not connected to any other files. New Features and Design Updates is a separate Figma file for new features and improvements. This file has access to components, colors, and font styles from file version 1.0. When the Figma file version 1.0 ends its lifecycle, we archive it and create a duplicate of this file. This file will be the Figma file version 2.0, and it is our new main file. Now, we’re working with this 2.0 file, and it will receive new features or updates in the future. The Figma file version 1.0 has become low maintenance, where we only make minor changes. We are focusing our full attention on the Figma file version 2.0. We added tabs for each page in both the 1.0 and 2.0 files to facilitate navigation. Thus, it’s easier to switch quickly between the previous design versions and the New Feature File. While duplicating Figma files solved many issues, it also introduced new challenges. Managing many files requires discipline, and ensuring consistency across versions demands extra effort. Yet, for our needs, the advantages outweighed the disadvantages.
Conclusion. Our project has made huge progress. We began by locating all designs on a single Figma page. Now we duplicate entire files and manage new features/improvements in a separate Figma file. Maybe we will enhance our process even more or try something new one day, but for now, this approach works for us. As a result, our processes were impacted on many levels. Here is what we achieved: Removed irrelevant designs from the file, which now match the implemented version. Made a clear distinction between the current design and updates. Created a version history for each app version. All links in Jira, Confluence, and Slack do not break and will remain active forever. Organized and created a Table of Contents to provide an easier way to find designs. Began to receive fewer questions about how to find something in Figma. That’s great progress. Who knows, perhaps Figma will improve branching someday. Let users change specific parts instead of the whole file. This will make versioning easier.
