Salesforce deployment roadmap: from inception to implementation

Working with ‘releases’ or Salesforce deployments can be a real puzzle for Developers, Consultants, and other Salesforce professionals. The more complicated your Salesforce setup gets, the trickier it is to perform the Salesforce deployment process without causing a ripple effect.

  • Published 14 Feb 2024
  • 19 mins read
Salesforce deployment roadmap: from inception to implementation
Table of contents

Hutte Expert Panel

Here are the experts we collaborated with to bring you unique insights.


Article Summary Box

Article highlights

  • Version control is essential in Salesforce DevOps, not only for tracking changes but also for maintaining a robust history for code reviews and rollbacks, with Git playing a crucial role.
  • Hutte enhances deployment flexibility by allowing the deployment of changes from development environments like scratch or sandbox orgs to any target org, streamlining both full and validation deployment processes.
  • Effective CI/CD practices in Salesforce DevOps significantly reduce manual errors, increase code quality, and expedite the release of new features, by integrating code changes into a shared repository frequently and releasing validated changes swiftly.

Once you've sorted out a solution in a sandbox and made it through testing (including the critical user acceptance testing [UAT]), the next big step is to bring those changes into the production environment. But mind you, deploying to production isn't a walk in the park.

If you have any experience with production deployments, you know what I’m talking about. Things often go south while working with releases. But what’s the least you can do to ensure everything goes right? Understand the basics! Hence, in this blog, I lay down the step-by-step process to understand the Salesforce deployment process.

But first, let’s have a look at the methods of Salesforce deployments.

Methods of Salesforce deployments

Every project in Salesforce is different, and the same goes for deployments. Let's break down the different ways we move stuff around in Salesforce.

Change sets

Change sets serve as a user interface tool facilitating the deployment of customizations from one Salesforce environment to another. With change sets, you can select specific components, such as custom objects, workflows, and Apex classes, streamlining the deployment process. More on it later.

Salesforce DX (Developer Experience)

It is probably the most used deployment type in Salesforce sandboxes. Salesforce DX represents a paradigm shift in Developer tools, emphasizing source-driven development. The command line interface (CLI) enables Developers to perform various tasks, emphasizing version control and collaboration.

Ant Migration Tool

The Ant Migration Tool complements change sets and Salesforce DX by providing a programmatic metadata retrieval and deployment approach. You can use this command line utility that supports the scripting of complex tasks. It also offers features like batch processing for the structured deployment of numerous components.

👉 Author's note: Remember that the Ant Migration Tool has reached its end of life as of Winter '24.

Use an external deployment solution

There are many valuable external deployment solutions you can incorporate into your workflow. Many of them do, however, pose some challenges that are beneficial to keep in mind.

These solutions include:

  • Salesforce native change sets: They are outdated, have a poor UX, and tend to be error-prone.
  • Salesforce command line: It is excellent for deployments but is designed with experts in mind.
  • Org to org deployments: Gearset and Salto are good tools to deploy from org to org. However, tools like these leave some problems unanswered, such as presenting a clear source of truth and giving an overview of what feature went to production.
  • Salesforce DevOps Center: As it is still very immature, it can be slow-moving and lack support.
  • Copado: It streamlines an enterprise's software lifecycle and automates deployment tasks to speed up the release process. The downside is that Copado can be costly, and deployments must be executed 'the Copado way.'

🔎 Author's note: I thus recommend to use a combination of a more lightweight, modern UX tool – like Hutte – and combine it with open-source, like you can find on Hutte Recipes, to make your deployments automated from your Git host.

Document
Sign up for Hutte

Special considerations

You can use more methods and tools to manage Salesforce deployments, like Workbench, CI/CD pipeline (Jenkins, CumulusCI, Azure DevOps, etc.), and some third-party tools.

 

But there are two products with special considerations for Salesforce deployments:

CPQ deployments

CPQ deployments are a bit tricky because they involve special data relationships. Unlike metadata, each piece of data gets a unique CPQ ID, so you must carefully keep everything organized and avoid any mix-ups. With all the unique IDs and multiple data relationships, deploying changes between environments gets complex and error-prone.

Salesforce Industries

Salesforce Industries (or Vlocity) adds a bit more complexity to changes. When making changes, remember that these changes might act a bit differently compared to other parts of Salesforce.

Testing things out in a safe space before deploying with Vlocity is crucial. If you're working with it, make sure to chat with professionals already working on such deployments.

Steps involved in planning Salesforce deployments

Abraham Lincoln once said, "Give me six hours to chop down a tree, and I will spend the first four sharpening the axe." The same goes for Salesforce deployment processes.

Effective planning is the linchpin of a successful Salesforce deployment. This requires a pragmatic approach to assess organizational needs and strategically analyze the existing Salesforce configuration.

Here are some steps for you to have an error-free Salesforce deployment planning:

Requirements gathering

Before setting out and sailing, ensure you have everything you need. Salesforce production releases are often complex and super-important for businesses. Hence, ensure you are clear on the objectives, dependencies, and other requirements.

Define objectives

Clarify objectives with stakeholders

Set up meetings with key stakeholders to clarify deployment objectives. Ensure that these align with the overall business goals.

Stakeholder consensus

Try to put stakeholders on the same page to mitigate potential misalignments and secure commitment to shared objectives.

Measurable KPIs

Establish measurable key performance indicators (KPIs) to measure the impact of the deployment and gauge its success.

Identify dependencies

Component dependencies analysis

Conduct a thorough analysis of any possible dependencies between different components, identifying any interrelated functionalities or processes.

Resource allocation

Allocate responsibilities among team members based on identified dependencies, optimizing resource utilization.

Risk mitigation strategy

Develop a strategy to mitigate risks associated with dependencies, providing a contingency plan for potential bottlenecks. 

🧠 Author's note: Use your consultants!

Release planning

Unless you've created one custom object and some fields to deploy through a change set, you must plan your release. Planning a Salesforce release requires strategizing the timeline, cleaning up the backlogs, and more.

Release schedule

Timeline development

Developing a realistic timeline is one of the essential prerequisites of the Salesforce development process. A strategically developed timeline helps in dealing with any foreseen or unforeseen challenges.

Iterative release approach

Consider adopting an iterative release approach, allowing incremental enhancements. Breakdown all the changes into smaller chunks and deploy them in iterations.

Transparent communication

Communicate the release schedule transparently to all stakeholders and team members, ensuring everyone is on the same page regarding timelines and expectations.

Backlog prioritization

In my time as a Salesforce Developer, we were always neglecting the backlogs, which led to multiple problems during the production release. This is why backlogs need to be prioritized.

Criteria-driven prioritization

Develop clear criteria for prioritizing features and changes, considering factors such as business impact, user needs, and strategic alignment.

Regular backlog reviews

Establish a habit of regularly reviewing and grooming your backlog, ensuring that priorities remain aligned with evolving business requirements. You don't want to miss an open bug or an underdeveloped feature while deploying.

Agile flexibility

Embrace agility in the planning process, allowing for priority adjustments based on real-time feedback and changing circumstances.

Risk assessment

Once you've gathered all the information and requirements and planned the release, the next step is identifying and mitigating risks.

Identifying risks

Risk identification

Systematically identify potential risks associated with the deployment, covering technical, operational, and organizational dimensions. However, you'll be halfway there after you oversee all the backlogs and dependencies.

Stakeholder input gathering

This is an underrated trick, but you should actively seek stakeholder input to capture a broad perspective and insight into potential risks.

Documented risk register

Maintain a comprehensive risk register, documenting identified risks, dependencies, and their potential impact on the deployment.

Mitigation strategies

Detailed mitigation plans

Once you have the list of all the potential risks, develop detailed plans to mitigate them, outlining specific actions, responsibilities, and timelines.

Proactive communication

You should communicate the risk mitigation strategies to the relevant stakeholders, fostering transparency and collaboration.

Continuous monitoring

It helps if you implement continuous monitoring mechanisms to reassess risks throughout the planning process, allowing for dynamic adjustments to mitigation strategies.

Steps involved in executing Salesforce deployments

We are done planning your Salesforce deployment process. Now is the time for execution. In this section, we'll look into the intricacies of each step to provide a comprehensive guide for a successful deployment.

Environment preparation

Backup and snapshot

Backup and snapshot

Before anything, take a backup of the Salesforce instance, including data, metadata, and configurations. You can utilize Salesforce's native backup tools or third-party solutions to ensure a complete snapshot.

Snapshot documentation

Document a detailed snapshot of the current environment, capturing metadata configurations, workflow rules, and custom code. 

🗣️ Author's note: Don't forget to include information on profiles, permission sets, and sharing settings to recreate the environment accurately if needed.

Testing backups

Regularly simulate the restoration of backups in a sandbox environment to validate the completeness and accuracy of the backup process. Documenting and communicating the backup and recovery procedures to the deployment team is even better.

Data migration

Strategy development

First things first, formulate a data migration strategy based on the volume and complexity of data, considering factors such as data relationships and dependencies. Prioritize data cleansing and transformation steps to ensure data quality during migration.

Data mapping

Clearly define how data will be mapped from source to target, addressing schema differences between environments. You can use Salesforce or external data mapping tools to streamline the mapping process. Document data mapping rules and share them with relevant team members involved in the deployment.

Validation procedures

Implement validation checks post-migration to verify the accuracy and completeness of the migrated data. Match the source and target environments to address any discrepancies. Ensure stakeholders are involved in the validation process to ensure alignment with business expectations.

Deployment tools and processes

Let's talk about the two most commonly used Salesforce deployment tools.

Salesforce change sets

Salesforce change sets are instrumental in the packaging and deployment of customizations within the Salesforce platform. They serve as containers for bundling configuration changes, making them manageable and deployable as a single unit. Here's a breakdown of their role:

Packaging customizations

Change sets allow Developers to group a set of changes, including fields, workflows, and Apex classes, into a single package.

Deployment process

The process involves creating a change set in a source environment, adding components to it, and deploying it to a target environment.

Declarative development connection

Change sets closely align with declarative development by capturing configuration changes made through point-and-click tools in the Salesforce setup.

Configuration selection

Selection of specific components within change sets is crucial to ensure that only intended changes are included. This involves:

Component selection

You need to carefully choose the components to include in the change set, such as custom objects, fields, workflows, and Apex classes.

Thorough testing in sandbox

Emphasize the importance of testing these changes thoroughly in sandbox environments before promoting them to production to catch potential issues early.

Naming conventions and documentation

Implementing naming conventions and thorough documentation practices enhances change set manageability, making it easier to track changes and understand their purpose.

Dependency management

Managing dependencies effectively is vital to prevent issues during deployment. Make sure your team understands the following:

Understanding dependencies

We've already talked about it a few times. You need to know how changes to one component may impact others, emphasizing the importance of deploying related components simultaneously.

Use Salesforce dependency API

Leveraging Salesforce tools like the dependency API helps identify and address dependencies before initiating deployment, reducing the risk of deployment errors.

Collaboration for dependency resolution

Encourage collaboration among Developers and Testers to resolve dependency-related issues. Communication and collaboration are vital to ensuring a smooth deployment process.

Salesforce CLI

Salesforce CLI is a versatile tool for automating deployment tasks, including metadata deployment, data loading, and script execution. Its capabilities include:

Automating deployment tasks

Salesforce CLI enables the automation of deployment tasks, ranging from deploying metadata components to loading data and executing scripts.

Common deployment commands

CLI comes with some common commands used in deploying metadata changes, retrieving modifications from an org, and executing tests to ensure code integrity.

Script execution

Salesforce CLI facilitates script execution, allowing Developers to create automation scripts that enhance deployment efficiency.

Scripting capabilities

You can never make development and deployment processes efficient enough. However, exploring the scripting capabilities of Salesforce CLI adds another layer of efficiency to the deployment process.

Reusable scripts

Developers can create reusable scripts for complex deployment scenarios, streamlining the execution of repetitive tasks.

Version-controlled scripts

You should use version-controlled scripts to ensure traceability and collaboration among team members. This practice enhances transparency and supports teamwork in the development process.

Best practices documentation

Documenting best practices for script development and maintenance ensures that Developers follow standardized procedures, reducing the risk of errors and promoting consistency.

Integration with version control

Emphasizing the integration between Salesforce CLI and version control systems – like Git – is crucial for maintaining a controlled deployment workflow.

Controlled deployment workflow

The integration allows for a controlled deployment workflow, enabling Developers to manage changes, track versions, and collaborate seamlessly.

Branching and merging strategies

Get a clear understanding of branching and merging strategies within version control systems. This allows for parallel development efforts without compromising code integrity.

Testing

Testing before and after deployment is non-negotiable. In this section, I'll explore the intricacies of testing, including unit testing, integration testing, UAT, and automated testing, followed by a detailed look into the execution phase.

Unit testing

Unit testing involves testing individual components, such as Apex classes, triggers, or methods, to validate their functionality in isolation. It ensures each individual component is working fine.

The importance of unit testing in the Salesforce deployment process is that it:

  • Ensures each component functions as intended
  • Identifies and rectifies errors early in the development cycle
  • Facilitates the maintenance of code integrity and stability.

Integration testing

A step further from unit testing, integration testing verifies the seamless interaction between different components within the Salesforce ecosystem, ensuring they work cohesively.

The importance of integration testing in the Salesforce deployment process is that it:

  • Validates the interoperability of integrated functionalities
  • Detects issues arising from the collaboration of multiple components
  • Assures the overall system functions harmoniously.

UAT

UAT involves end-users testing the system to validate that the deployed changes meet their expectations and align with business processes.

The importance of UAT in the Salesforce deployment process is that it:

  • Gathers valuable feedback from end-users
  • Confirms alignment with business requirements
  • Ensures the system meets user expectations.

Automated testing

Automated testing involves using tools and scripts to execute test cases, enhancing the efficiency and accuracy of the testing process. It frees the testing team from various manual tasks and allows them to run tests 24/7.

The importance of automated testing in the Salesforce deployment process is that it:

  • Reduces manual effort and human errors
  • Facilitates continuous validation of changes in the development pipeline
  • Improves consistency and repeatability of test scenarios.

Deployment execution

Phew! That was long, but we aren't done yet. We are now in the final phase of deployment, and all that remains is the execution. Here's a breakdown of essential steps to ensure a smooth deployment:

Monitoring and communication

Real-time tracking

Utilize Salesforce deployment monitoring tools to monitor deployment progress in real-time. Stakeholders can easily access dashboards or reports displaying deployment metrics and status updates.

Clear communication channels

Establish straightforward communication channels to update stakeholders on the deployment status. Designate a central point for inquiries and regularly share updates through email, chat, or collaboration platforms.

Periodic check-ins

Schedule periodic check-ins with key stakeholders to address concerns and provide clarification. These check-ins foster collaboration, allowing stakeholders to provide feedback and seek clarifications during the deployment process.

Rollback plan

Preparation for unforeseen issues

Develop a comprehensive rollback plan that outlines the steps to revert changes in case of unexpected issues. Identify specific triggers that would necessitate a rollback, such as critical errors, data corruption, or performance degradation.

Testing rollback procedures

  • Regularly test the rollback procedures in a sandbox environment to ensure their effectiveness.
  • Document the rollback testing process, including success criteria and steps for each scenario.
  • Iteratively refine the rollback plan based on testing outcomes.

Best practices for successful Salesforce deployments

So far, I have discussed the steps involved in planning and executing Salesforce deployments. It was lengthy, so why not make it easy for you.

Here are some best practices for Salesforce deployments that you must keep in mind:

Incremental deployments

Deploy changes in small, incremental releases rather than large batches. This reduces the risk of errors and makes troubleshooting more manageable.

Continuous integration

Implement continuous integration practices to merge code changes, ensuring consistent integration and automatic testing.

Rollback plan and validation

Develop a rollback plan detailing steps to revert changes if needed. Perform validation tests post-deployment to confirm success.

Cross-functional collaboration

Sustain collaboration between development, testing, and operations teams. Encourage open communication channels for swift issue resolution.

Environment seeding

Pre-populate sandboxes with realistic data to mimic the production environment, aiding accurate testing and reducing the likelihood of data-related issues.

Governance and compliance

Establish governance policies to ensure adherence to best practices. Ensure compliance with industry regulations and internal standards.

Backup and restore strategy

Regularly backup configurations and data before deployments. Establish a reliable restore strategy for quick recovery in case of issues.

Change set validation

In case you're using change sets, prioritize their validation in a sandbox environment before production. Identify and resolve issues early in the deployment lifecycle.

Monitoring and alerts

Implement monitoring tools to track deployment progress and system health. Set up alerts for any anomalies or unexpected behaviors during deployments.

UAT

Involve end-users in UAT to validate changes from their perspective. Address user feedback before moving changes to the production environment.

Documentation beyond code

Document not only code changes but also configuration modifications. Include details about dependencies, integrations, and any manual steps.

Post-deployment communication

Communicate the completion of deployments to all stakeholders. Provide a support channel for users to report issues post-deployment.

Training for Administrators

Train Salesforce Administrators on new features and changes. Ensure they are equipped to handle potential user inquiries.

Performance testing

Conduct performance testing, especially for large-scale changes. Identify and address any performance bottlenecks before deployment.

Thorough documentation

Maintain detailed deployment plans and document post-deployment changes for future reference.

Factors to consider for a smooth Salesforce deployment are: Follow Git-based development. Have a robust branching strategy and proper development processes that are well-followed by team members. Have a proper org strategy with aligned environments. Ensure the necessary checks (such as deployment validations, Apex tests, and others) are green before doing the real deployment. Deploy only delta-changes or use artifacts (for example, Flxbl promotes the modular architecture approach).

Manuel Moya

Salesforce DevOps Consultant & Application Architect

Source: Hutte

Deploy step-by-step

It is no news that a Salesforce development process involves:

  1. Requirement gathering
  2. Development
  3. Testing
  4. Deployment.

Admins, Developers, Consultants, and all other stakeholders are well aware of the cumulative process. However, the Salesforce deployment process is a bit tricky. There is a lot to do and in the proper manner.

🧭
So, don't hesitate to use this blog post as your guide to implementing various steps and best practices to help ensure a smooth and successful deployment.

Spring Release Notes Box
Spring Release Updates
Enhanced Salesforce DX Capabilities
The Spring Release likely includes updates that further streamline version control and team collaboration through Salesforce DX, which would be directly applicable to organizations looking to enhance their deployment strategies as outlined in the Hutte.io article.
New Deployment Tools and Features
With Salesforce focusing on AI and automation enhancements, the Spring Release introduces new tools or features that automate or simplify the deployment process, addressing some of the challenges mentioned in the Hutte.io deployment guide.
Security Enhancements
Given the emphasis on Salesforce's new security layers like the "Trust Layer," these features can be integrated into the security strategies for deployment, ensuring safer and more reliable deployment practices, which is a concern noted in the Hutte.io article regarding the use of external tools.
AI and Automation in Deployment Processes
The introduction of AI capabilities like Einstein Copilot in the Spring Release could provide opportunities to automate certain aspects of Salesforce deployments, potentially reducing the complexity and error rates associated with manual processes discussed in the Hutte.io article.

Last updated: 12 Jun 2024