Version control is an essential practice for modern software development on the Salesforce platform. It goes far beyond just tracking code changes in a Git repository and can transform how agile teams build, test, and deploy software.
Adopting Salesforce-specific version control best practices helps create a more efficient, collaborative development environment and improve the overall release management process. In this blog post, we’ll cover some of these best practices that will help you on your way to DevOps success.
Craft consistent commit messages
Thoughtful, consistent commit messages are a cornerstone of good version control hygiene when developing on the Salesforce platform. They clearly document the reasoning behind each metadata change, easing code reviews and debugging down the line.
Tips for creating better commit messages
- Use a short, active subject line under 50 characters summarizing the metadata change.
- After a blank line, provide a brief explanation of what was changed in the metadata and why.
- Reference any related issues or bug tickets fixed in the commit. This links code changes to tasks.
- Use consistent messaging across all commits, following team conventions.
- Use active voice and present tense to keep messaging clear and concise.
Some teams like to adopt naming conventions that not only read well to a human, but automated processes too. Techniques such as Semantic Versioning and Conventional Commits provide a template for this type of commit message.
You should also consider extending these conventions to your pull request notes as well. Any chance to provide context for your changes should be taken.
Make small and frequent commits
When using version control with Salesforce, it’s best practice to make small, frequent code commits for both Apex code and metadata changes.
Instead of bundling many changes into one large commit, make commits granular. Each commit should represent one logical change, such as adding a field, fixing a bug, or refactoring a class. Salesforce DX’s approach aligns well with version control, particularly due to its granular handling of metadata changes. Instead of committing an entire object’s metadata for one field modification, you can target just the field’s metadata. This is a technique not supported by older Salesforce platform release management methods like change sets.
Get into the habit of committing early, whenever a task is complete rather than waiting until the end of the day. There are many benefits to committing small slices as frequently as possible:
- Enables easy understanding of changes during review. Isolates each change.
- Simplifies debugging by pinpointing when an issue was introduced.
- Avoids lengthy and complex commits that are hard to unravel.
- Maintains visibility into progress as commits are made incrementally.
- Lessens chance of complicated merge conflicts down the line.
Choose the right branching strategy
Branching is a pivotal part of an effective version control workflow on the Salesforce platform. The branching strategy you choose should fit the team size, project complexity, and release timing. In many strategies, where feature branches are used, it’s a good idea to give the branches meaningful names, possibly including a ticket number if systems such as Jira are in use.
A branching strategy can also use various sandboxes to map each phase of your Salesforce org process, from development to user acceptance testing, and then to production, which forms an essential part of your branching strategy design. This helps isolate work in progress and allows thorough testing before it reaches the main branch (also known as the master branch in some configurations).
Common branching strategies
- Feature branching isolates feature work in branches separate from the main branch. Feature branches are short-lived by design and it’s recommended to delete them once they’re merged into the main branch.
- Gitflow manages branches for releases, hotfixes, and integration. This is a more complex but robust framework.
- Trunk-based development uses a single main branch for integration, which enables continuous delivery.
- GitHub flow uses feature branches from a central main branch. This is a simple but flexible model, where changes are merged back into the main branch only after review and successful testing. This strategy is great for projects that deploy frequently.
Considerations when selecting a branching strategy
- How many developers are on the team?
- How complex is the project?
- What does the release schedule look like?
- What development style is being followed (agile, waterfall, etc)?
- How much collaboration and code isolation is needed?
- Is continuous integration or delivery a priority?
Discuss openly with your team to find the most fitting approach, considering our post on Git branching strategies for Salesforce developers.
Perform code reviews
Peer code reviews are another vital version control process on the Salesforce platform. Reviews help improve overall code quality by catching issues early and make sure standards and conventions are followed consistently. They also aid the spread of knowledge amongst teammates by sharing different solutions and making code more maintainable and readable via feedback.
Best practices for code reviews
- Review pull requests as soon as you can to avoid blocking progress.
- Use checklists to make sure all code is checked thoroughly.
- Add automated linting and testing tools to assist human reviewers.
- Maintain a positive tone focused on improvements not criticism.
Overall, code reviews boost collaboration, align coding styles, and reduce bugs before they impact the end users.
Implement branch protections
Setting up branch protections for your most crucial branches means certain conditions have to be met before anything can be merged to them. With features like mandatory code reviews, automated checks, and resolving conversations before merging, these rules help catch issues early. They also encourage collaboration, accountability, and good habits across the board.
Merge code changes regularly
Whether using feature branching or trunk-based development, regularly merging code changes is critical on the Salesforce platform.
Frequent merging syncs feature branch work with the main branch keeping the codebase updated. This process surfaces merge conflicts early while they are still small and manageable, and helps to detect new bugs introduced by changes as early as possible.
Tips for smoother merging
- Make merging a daily habit to integrate changes from feature branches.
- Always test code in a sandbox once you’ve merged.
- Resolve merge conflicts locally before pushing to the main branch.
- If supported, use pull requests to help with code reviewing.
Regular merging keeps all developers on the same page code-wise. This alignment means faster delivery with fewer bugs.
Codebase traceability
Traceability in version control helps track the complete history of code changes on the Salesforce platform. This ability to trace changes helps pinpoint when and where bugs or issues originated, maintaining accountability for changes as each is assigned to an owner. You also have the potential to understand past design decisions by studying code evolution. Traceability also helps with meeting compliance requirements for auditing and governance.
Improving traceability of your changes
- Write clear, detailed commit messages that document the “what“ and “why“ of each change.
- Use issue tracker integration to connect code commits with tasks or tickets.
- Follow consistent branching strategies that group related changes.
- Enable blame or annotate features to see who made each code change.
With robust traceability, you can navigate your codebase’s history with clarity.
Take advantage of automation
Automation supercharges your release process by handling repetitive tasks that can slow down the pipeline. This leaves developers free to focus on complex problems knowing that their deployments are being looked after. Automation processes are extremely important in Salesforce DevOps and most frequently form part of an overall CI/CD pipeline.
There are several common processes that are candidates for automation, such as building and packaging code for deployment and running extensive test suites to validate code integrity. You can also introduce automation for performing code linting and style checks during review as well as deploying code updates frequently and reliably to Salesforce sandboxes.
Benefits of automation
- Reduces human errors and promotes consistency.
- Speeds up development by eliminating tedious manual steps.
- Improves code quality and bug detection.
- Helps mature continuous integration and delivery practices.
Integrating automation transforms code delivery from a slow manual process to a robust automated pipeline.
Version control best practice checklist
Excellent version control practices help collaboration, release quality, and seamless automation when deploying to Salesforce. on the Salesforce platform. Leading Salesforce teams are seeing success in DevOps by following some simple version control best practices:
- Craft consistent and meaningful commit messages.
- Make small, frequent code commits.
- Select a branching model fitting team size and project complexity.
- Perform thoughtful peer code reviews with automation tools.
- Continuously integrate code via regular merging between branches.
- Encourage comprehensive traceability of all codebase changes.
- Automate repetitive processes like building, testing, and deploying.
You can find out more about the importance of version control on our recent DevOps Diaries podcast episode, along with a handful of other great topics on Salesforce DevOps.
Use version control with Gearset
By following these Salesforce version control best practices teams are able to deliver higher quality, more reliable code within a streamlined development lifecycle.
You can learn more about version control in our whitepaper or if you’re ready to get started on your DevOps journey, see how Gearset seamlessly integrates with version control by signing up for your free trial today.
