This article answers the following questions about feature branching: What is feature branching? How do you implement feature branching? Why is feature branching important to version control on enterprise apps?

Enterprise apps should help businesses grow, not slow them down. How can product development teams deliver a lot of features without introducing bugs every time a sprint is completed?

Resolving a consistently heavy load of merge conflicts makes projects over-budget and overdue. How can teams avoid them altogether?

The solution to both of these problems is feature branching.

It’s easy to spot a team that’s not implementing feature branching. They will consistently miss commitments and complain about deployment being overly complex. They will size work much larger than you think they should. They’ll consistently break each other’s code, resulting in poor morale and lots of blaming. And they may spend half a day or more resolving issues every time they merge the changes to their features. All of these problems combine for a software project that tends to be behind schedule and over budget.

Concerned CTOs or CMOs auditing development teams for deficiencies should investigate how developers are implementing version control, continuous deployment, and development branching. Efficient and dependable release processes, including feature branching, go a long way toward keeping projects on time and on budget.

At Praxent, we routinely integrate feature branching into our custom software development and devOps strategy. On a recent project for a client in the hospitality industry, a team of four at Praxent delivered 70 points per sprint, merging, at times, five or six different feature branches. In three sprints, our team spent a total of less than one hour resolving merge conflicts.

Impressed? Hopefully, you can whip your team into shape with feature branching and see the same results!

>> Not sure if you’re software development partner is the right fit? Here are three critical questions to ask before settling on a software development company.

What Is Feature Branching?

Feature branching allows developers to code different features of a product separately, without stepping on each other’s toes. Teams that implement feature branching can develop solutions for one feature without creating problems in another — all while collaborating with each other to ensure consistent code across all features.

A well-known devOps strategy, feature branching assumes that software development projects should progress smoothly, efficiently, and somewhat predictably. The term “devOps” comes from “development” and “operations.” DevOps is a set of processes that facilitate collaboration between software development and software operations. It ties the principles, practices, and tools of software operations into all stages of development, from initial brainstorming and design all the way to deployment and ongoing support.

Teams that employ devOps properly save time and reduce risk by automating the processes used to develop each new feature of the product.

>> Learn more about how devOps can impact the progress of your software development project.

How To Do Feature Branching

Feature Branching, Step-by-Step

As different developers work on similar parts of an app, the changes they create can conflict with one another. It can take a lot of extra time to figure out how to integrate those changes together. This is called merge conflict.

With feature branching, each developer creates a feature starting with the same source code. After two weeks, they come back together and merge their changes back into the source. This simple yet powerful process helps prevent excess merge conflict and expedites the development process.

Here is a step-by-step guide for implementing feature branching:

  1. Take a look at your backlog and identify the most relevant priorities. It’s important to strategically assign features so that developers are not working on the same exact area of the software product, if at all possible.
  2. Assign features that are well contained. Can different developers work on these features separately and with minimal conflict?
  3. Have each developer create a feature branch. (Ex. “feature-user management,” “feature-reset password,” “feature-download reports”)
  4. Begin the sprint. Allow each developer to work on their feature without any interference from other developers. Now that your team is working in feature branches, developers can even make changes to the same file without issues.
  5. Once a developer completes a feature, they merge it into the original branch in their development workflow.
  6. Developers handle all merge conflicts after merging their updates back into the original branch.

Rather than running into merge conflicts daily, developers can manage merge conflicts once and be done until the next merge. Not only that, but they can remain focused on their mission throughout the sprint without having to worry about what other developers are doing.

Feature Branching for Version Control

Feature branching becomes especially important for enterprise app development teams looking to perfect their version control practices.

>> Learn more about Version Control on Enterprise Apps in our eBook.

Version control is the devOps practice of ensuring each technology across a given product is using a chosen and reliable version of the technology — compatible with each other component within the product ecosystem. For developers, version control requires a strategy for efficiently and seamlessly releasing new versions of an app or updating existing ones. Without version control in place and working properly, updates and changes happen slowly and cause new problems, creating a lot of risk for users.

To prevent version control breakdown, product teams can implement continuous deployment and development branching. Continuous deployment is a devOps strategy that allows teams to automatically and continuously move updated code into production. This helps keep users connected with the most up-to-date and reliable version of the application at all times.

When it comes to version control for enterprise apps, the missing ingredient for most teams is what to do with code that is not yet in development, staging, or master.

In a continuous deployment context, teams need a structure for holding pieces of software not yet deployed and moving features down the pipeline at each stage of completion. That structure is called development branching. With development branching, developers get intentional about where they place code before it gets to the first branch in the stream. With the added clarity and direction provided by development branching, teams can keep projects moving forward at maximum efficiency.

So how do you implement development branching effectively? Create a feature branch for any job that you anticipate requiring more than a sprint’s worth of work. At the beginning of every sprint — and after the previous sprint has been merged into the dev branch — perform a fetch, then rebase from origin/dev to your feature branch and resolve conflicts immediately.

With this branching strategy in place, you can now deploy the dev version of your application to staging and production at will, without fear of being blocked by features that are in progress.

Learn More

At Praxent, we understand what businesses want out of software. Whether you’re a business owner researching software solutions for greater growth, or a CTO tasked with identifying the surest path of development for your company and its stakeholders, we’ve got your back. Our clients trust us to perform so that they can deliver value to their internal clients, supervisors, and ultimately their customers.

Next steps: Why Software Projects Fail

Plus 6 secrets to help yours succeed