Salesforce Version Control GIT

Flosum Version Control: The Joys of GIT — Minus its Baggage

GIT has a powerful distributed architecture and provides a rich set of commands for version control. It has been rapidly becoming a standard for the sophisticated and advanced user to do crafty things with source control, particularly in the open-source community.

Yet it has alienated a large part of the developer community. What could be the cause for that? Let us examine some of the key reasons why GIT is daunting for customers to adopt.

  • Too complex

    The pre-GIT client-server modeled centralized version control systems were simpler in that you needed to know a few things to use them – namely your sandbox, a repository, branches, and version control. With GIT and its distributed architecture, you now need to understand various other constructs such as an index, local repository, remote repository, treeishes, stash, and the list goes on. The information model with GIT has grown in complexity.
    The number of commands has increased significantly and simple tasks can require many more commands to accomplish.
    In addition, the terminology of the GIT commands has been confusing and problematic since it has reused CVS and Subversion (SVN) terms for completely different concepts.

  • Every user needs to know it

    Regardless of the experience and skillset of the developers and any other users, if GIT is being used for version control, every person using it has to undergo a steep learning curve to understand it.

  • Experts required to manage and maintain it

    Orchestrating and maintaining GIT requires dedicated skilled resources to administer the build infrastructure and the release management activities. For GIT, as the number of concurrent development efforts increases, it is critical to ensure that the working streams result in a stable release.

Furthermore, if you are a Salesforce customer, the consideration of GIT for version control becomes even more difficult. Many of those who adopted GIT have been looking for alternatives to simplify and streamline their source control needs.

  • Non-Salesforce-centric tool

    GIT is not an integrated solution for Salesforce. Salesforce is a cloud solution with unique needs for release management.
    The release management build infrastructure using GIT looks complicated and has to be carefully crafted. The GIT repository is external. Processes like deployment become unwieldy given that the repository exists outside of Salesforce. GIT is over-engineered for the purposes of Salesforce. And the list goes on…
    It is not a match made in heaven.

  • Compliance and certifications

    Given that GIT is a non-integrated tool, compliance and certifications are issues that have to be dealt with. HIPAA and PCI standards are prime examples that require third-party integrations with plugins from external vendors to try and mitigate these issues with GIT – thus compounding things further.

  • Deployment of builds is complex

    Deployment from GIT is cumbersome and painful to deal with. It involves using a combination of the Migration Tool (FMT) or Eclipse and Ant build scripts to fetch from GIT branches and deploy to target organizations.

  • High Total Cost of Ownership

    Build servers, client machines, third-party plug-ins, installation, integration, on-going maintenance, dedicated personnel for integration, and release management all add up to a high total cost of ownership.

Why Flosum Version Control?

There is a community of unhappy GIT Salesforce customers. Then again, there is an even larger majority who are wary of investing in any version control tool because of its challenges.

Flosum’s version control was envisioned, designed and developed with Salesforce and its customers in mind. Its goal was to have the power of GIT while making sure it was extremely easy to use.

Flosum Architecture

Flosum has an elegant and extensible architecture to solve the problems of release management in the Salesforce cloud. It is completely built on the platform and has no external footprint.

Flosum has the same service level agreements (SLAs) as Salesforce and requires no special maintenance. It is as secure as Salesforce and provides the same level of certification and compliance you expect from the platform.

Key Benefits of Flosum’s Version Control

Since Flosum is built entirely on the platform, a native implementation of version control was done to provide a fully integrated and secure repository within Salesforce. The highlights that make the Flosum version control compelling are:

  • Declarative version control with intuitive user experience

    Flosum’s easy-to-use “Clicks, not Code” design makes it really simple to administer and be used by developers. Any Salesforce developer can learn and use Flosum’s version control in just a few minutes!

  • Deployments are easy and fast

    The Repository is contained within Salesforce. Patch-manifests are easy to construct from the Repository and, once qualified to be working, can be reused to deploy to other orgs.

  • Robust architecture

    Flosum’s version control has an architecture that allows multiple developers to collaborate and manage multiple streams of development. Its integrated solution is robust and removes the complexities of installation, management, and maintenance of external tools.
    See Table 1 and Diagrams 1 and 2 below.

  • Rich feature-set

    Flosum has all the key features and capabilities of GIT.
    See Table 2 below.

  • Compliance and security

    It is built on Salesforce, hence, it adheres to the highest level of security and compliance that the Salesforce platform provides out of the box.

  • Secure Repository

    All storage is maintained and managed within Salesforce.

  • Reduced Total Cost of Ownership

    Owing to its integrated design, there is no additional capital or operational expenses to manage the infrastructure.

Flosum’s version control integrates seamlessly with other features of Flosum, like Continuous Integration and Patch Deployment, to provide a full and compelling Release Management solution.

Diagram 1: GIT Version Control Architecture



Diagram 2: Flosum Version Control Architecture



Table 1: Architecture Equivalents

WorkspaceDeveloper Org
Staging areaSnapshot
Remote repositoryFlosum repository


Table 2: Key GIT Commands Equivalents

GIT initCreate a Branch
GIT addTake a snapshot for commit
GIT rmRemove files from the Branch
GIT commitCommit changes to the Branch
GIT statusShow all components in the Branch. Merge of Branch shows files that are different from the Repository
GIT branchList, create or delete Branches
GIT mergeIncorporate changes from workspace to Branch and from Branch to Repository
GIT pushCommit changes to the Repository
GIT logView list of commits on a Branch
GIT showView details of a given metadata/programmatic component
GIT diffComparison between metadata components


Decision-Making Simplified

You know your Salesforce implementation must have version control. Like Salesforce, compliance is essential and so is the ease of use for full adoption — be it by a developer, an administrator, or a business analyst who touches the implementation. With these under its belt and its rich feature-set, Flosum’s version control makes the baggage of GIT moot!