Simplify Your Salesforce Deployment Checklist

When you’re delivering frequent configuration changes to your customers at scale, it’s essential to have a clear, well-defined release process. Salesforce automation tools — in combination with a version control system like Git — can help define and streamline many of the key steps in your workflow.

Use this Salesforce deployment checklist to ensure that you deliver code and configuration updates smoothly, safely, and effectively.

1. Define Team Roles and Responsibilities

Establish clear guidelines for who in your team does what, and when. Successful deployment teams typically define roles as follows:

  • Administrator: Develops features using declarative tools in Salesforce, commits changes to feature branch in Git, makes pull requests
  • Developer: Develops features using code, commits changes to feature branch, performs code review and code merge for test builds
  • Quality Assurance (QA): Tests and validates features deployed to the UAT org
  • Team Lead or Release Manager: Approves pull requests, performs final code merge for production

To collaborate effectively and minimize confusion during crunch time, make sure that all team members have a solid understanding of their responsibilities at every step of the deployment process in Salesforce.

2. Use a Project Management Tool to Track Tasks and Features

Instead of maintaining tedious spreadsheets of notes and activity logs, adopt a project management tool such as Jira. This issue-tracking tool serves as the central hub for team communication and collaboration as well as project documentation like feature specs and test plans. Jira, in particular, also integrates well with certain Salesforce deployment tools.

3. Set Up Dedicated Orgs for Development and Testing

Every Salesforce admin and developer should have their own development sandbox in which to create and test their assigned features prior to build integration. Individual dev sandboxes allow you to track the source and status of each feature and to deploy features incrementally in a continuous integration (CI) workflow made possible by Salesforce automation tools.

For build integration and testing purposes, set up a shared UAT org with the potential for Salesforce test automation. This org will receive incremental deployments of features from individual dev sandboxes so that QA can continuously test the usability of these features in an environment that simulates the customer’s production org. After all the project features have been tested and validated in the UAT org, your team lead can clone the UAT deployment for delivery to production.

4. Establish Git as the Single Source of Truth

The Git version control system is widely recognized as the industry standard for DevOps teams. By integrating your Git repository with third-party Salesforce automation software, you can set up powerful CI workflows that speed up your integration, testing, and deployment processes exponentially.

To set up your team’s source control repository, download Git and decide on a Git collaboration platform, such as Bitbucket, GitHub, Gitlab, or Azure DevOps. In the Git repository, make sure to store your team’s source code (Apex, Lightning components), as well as configurations such as objects, fields, validation rules, and workflows.

For Git to function as your team’s source of truth, it’s important to track both Salesforce code and Salesforce configurations in the repository. Once you’ve set up the foundation for your repository, you can move on to setting up your deployment pipeline around Git as the centralized gating platform for source code.

5. Create Git Branches for UAT and Production

At the start of every new release cycle, set up two main branches of code in your Git repository: UAT branch (for the UAT org) and master branch (for the production org).

First, make sure that the master branch reflects the current configuration of the customer’s production org. Using a third-party Salesforce DevOps tool, deploy the customized metadata from the production org to your Git master. The master branch now contains the baseline code that will receive the approved changes representing the new release.

Next, create a UAT branch off the master branch. Using a third-party DevOps tool again, deploy the Salesforce configuration from your UAT org (which you created during checklist item #3) to the UAT branch. The UAT branch now represents the baseline working code that will receive incremental deployments of new features as they are queued for integration and testing.

By keeping the master and UAT branches separate, your team can safely develop and deploy test versions of features without disturbing the master code or production environment.

6. Set Up Automated CI Workflows

With an effective DevOps tool sitting between your Git repository and your Salesforce orgs, you can set up CI processes that streamline and accelerate your team workflow through Salesforce deployment automation.

For example, you can configure a CI process that automatically deploys changes to the UAT org when those changes get committed to the UAT branch in Git. This process ensures that any new feature will first need to go through the canonical Git workflow (pull request, code review, approval, code merge and commit to branch) before it is deployed to the UAT org for testing.

Similarly, you can create a CI process that automatically deploys changes to the production org when those changes get committed to the master branch. Or, for an extra measure of caution, you can configure the master commits to trigger a validation checkpoint instead of deploying changes immediately.

7. Develop, Test, Deploy, and Repeat

Now that you’ve adopted Git and set up the necessary workflows using a Salesforce automation tool, you can start spinning your releases.

Admins and developers go off into their dedicated sandboxes to work on their respective assignments. When a feature owner determines that their feature is ready for test integration, they commit their changes to a feature branch in Git and create a pull request, initiating a code review by the team.

Once the team reviews and approves the feature code, the team lead commits the code to the UAT branch. This action triggers Salesforce deployment automation, as the approved feature is deployed to the UAT org. QA tests and validates the feature for usability.

After the feature passes UAT, the team lead clones the previous deployment and sets the Git master as the target. Once the feature code gets committed to the master branch, the feature is automatically deployed to the production org or queued for a final validation review, depending on the settings that you’ve specified in your Salesforce automation software.

Try Team Collaboration and Sharing with ClickDeploy

ClickDeploy Enterprise is a cloud-based Salesforce DevOps tool that lets you deploy your customizations at scale with lightning speed. ClickDeploy also supports robust integrations with Jira and popular Git repositories such as Github, Gitlab, BitBucket, and Azure DevOps.

To explore how ClickDeploy can help simplify and streamline your Salesforce deployment checklist with integrated deployment tools in Salesforce, log in to start your free three-week trial.