Creating agile CI/CD releases in Salesforce

Table of Contents

Agility and continuous improvement are key in today’s fast-paced software development environment. Salesforce is no exception and requires a sophisticated approach to software delivery to keep up with the rapid pace of business demands. Organizations leveraging Salesforce for their CRM needs must adopt a robust Continuous Integration/Continuous Deployment (CI/CD) strategy to stay ahead. 

In this blog post, we’ll explore how to create agile CI/CD releases in Salesforce, focusing on best practices, tools, and strategies to streamline your release process.

CI/CD and Agile

CI/CD stands at the heart of modern software development practices, closely tied to the Agile methodology. Continuous Integration (CI) involves automatically integrating code changes from multiple contributors into a single software project several times daily. Continuous Deployment (CD) extends this by automatically deploying all changes that pass through the pipeline to production. They ensure that software can be developed, tested, and released to customers quickly, efficiently, and reliably.

Agile methodology complements CI/CD by emphasizing iterative development, customer feedback, and flexibility to change. Together, Agile and CI/CD form a powerful synergy that enhances product quality, accelerates delivery timelines, and improves collaboration across development teams

Why Agile CI/CD Matters for Salesforce

Salesforce’s dynamic and multi-tenant architecture poses unique challenges and opportunities for CI/CD. The platform’s metadata-driven nature allows developers to build and customize applications without writing extensive code. However, to leverage Salesforce’s capabilities fully and ensure smooth deployments, an agile CI/CD process is essential. It enables teams to:

  • Reduce Deployment Risks: Frequent, incremental changes are easier to manage and troubleshoot than massive, infrequent updates.
  • Enhance Team Productivity: Automated processes free up time for developers to focus on higher-value tasks, such as feature development and optimization.
  • Improve Release Quality: Continuous testing ensures that issues are identified and resolved early in the development cycle, enhancing the quality of releases.

Setting Up an Agile CI/CD Pipeline in Salesforce

Although there are more options, the three most common ways to set up our Salesforce CI/CD pipeline are Source-driven, using GitHub or Bitbucket, for example, a Salesforce-native tool such as DevOps Center, or a third-party tool like Copado.

Source-driven (Github / bitbucket)

Regardless of the chosen platform (GitHub or Bitbucket), the tools provided by these platforms (GitHub Actions or Bitbucket Pipelines) will need to be utilized. It’s highly recommended that Salesforce DX facilitate development and change management in Salesforce. Instead of the org, your version control system is the source of truth. Salesforce DX also provides a powerful command-line interface (CLI), which removes the complexity of working with your Salesforce org for development, continuous integration, and delivery. It can connect with Scratch orgs, sandboxes, or developer orgs.

Devops Center

Salesforce DevOps Center is a powerful solution provided by Salesforce designed to enhance the experience of change and release management for Salesforce applications. The DevOps Center serves as a central hub for managing releases and provides a unified workspace for both low-code and pro-code development team members.

Set Up Your GitHub Project Repositories: Each DevOps Center project needs its repository to store project changes. While you’re working on the project, the repository is the team’s centralized source of truth to manage changes. For now, the DevOps Center only supports GitHub as the source control system for its projects

Add the Release Environment for the Project: projects require a release environment (usually your production org) and one developer environment. All team members must be users in this environment if they want to be able to perform deployments from within the DevOps Center.

Add Development Environments to the Project: Add the source-tracked development environment you created for each developer working on the project. Sandboxes must be Developer or Developer Pro sandbox with source tracking enabled. Other sandbox types don’t support source tracking, a requirement for development environments.

Setup your pipeline: After you define development environments and a release (production) org, you have a basic pipeline. However, this is a bad practice, and you should add more stages to your pipeline. The most common stages are the integration stage and UAT stage. 

Bundle work items: In the earlier stages of the pipeline, allowing users to promote individual work items from one stage to the next is more common. As you move to the later stages of the pipeline, it’s often desirable to have more predictability and the ability to version the sets of changes that are promoted and ultimately released. The bundling stage is the point in the pipeline when you transition from the more flexible/individually selectable work item promotion to the more predictable/versioned promotion. All stages to the left of this stage allow for individual work item promotion, and all stages to the right allow for versioned work item bundle promotion. The bundling stage is defined when you configure the pipeline. The versioned work item bundle created in the bundling stage and promoted through subsequent stages provides improved consistency because the changes contained in it have been merged into a unit that you can promote consistently and predictably from stage to stage.


Copado is a comprehensive, extensible, and secure Salesforce DevOps solution. It serves as the #1 DevOps Platform for Salesforce. 

Set Up Your Project Repositories: Depending on the current status of your Salesforce environments, initializing a Git repository can be achieved in two ways. To initialize a Git repository for closely synced environments, a single main (often referred to as “master”) branch can be seeded, followed by creating new Git branches as copies of the main branch. To initialize a Git repository for environments significantly out of sync, each Git branch created must be seeded individually to ensure branches most closely resemble their corresponding Salesforce environment.

Configuring a Pipeline for Use with Work Items: Similar to DevOps Center, when using Copado, we must also configure the different stages we want in our pipeline. While updating the Pipeline, you can include a Git repository for each stage following Development, and can enforce a mandatory in-app Approvals process. 

Best Practices for Agile CI/CD in Salesforce

Implementing Continuous Integration/Continuous Deployment (CI/CD) practices in Salesforce requires careful planning and adherence to them is crucial for efficient development, high-quality releases, and maintaining control over your codebase. Let’s explore some best practices:

Version Control  

Utilize a version control system such as Git to manage your Salesforce metadata. Ensure that all changes, configurations, and customizations are tracked in version control. This provides visibility into changes made by team members and allows for rollbacks if necessary.

Break down changes into smaller, incremental deployments rather than large, monolithic deployments. This ensures work items move smoothly through the release pipeline, reducing conflicts and promoting faster reviews and deployments.

Group all changes related to a specific feature or user story within a single branch. This simplifies tracking and ensures that related modifications stay together.

Sandbox Environments

Utilize Salesforce Sandboxes for development, testing, and staging environments. Use different sandboxes (e.g., Developer, Partial, Full) to mirror production environments as closely as possible. This ensures that changes are thoroughly tested in environments that resemble production before deployment.


Implement automated testing at various levels, such as unit tests, integration tests, and end-to-end tests. Use Salesforce’s native Apex testing framework for unit tests and consider using external testing frameworks for integration and end-to-end tests. Automating tests ensures the quality of changes and allows for faster feedback loops. Frequent testing ensures that changes are validated and issues are caught early in the process.

Define a rollback strategy to revert changes in case of deployment failures or issues in production. Keep metadata backups before deployment and document the steps required to roll back changes effectively. Automate rollback processes where possible to minimize downtime.

Create a DevOps Culture

While CI/CD tools lay the foundation, fostering a DevOps culture is essential. Encourage collaboration, agility, and continuous delivery across your development team.

Set up a CI pipeline that automatically triggers builds and tests whenever changes are pushed to the version control repository. Use CI tools like Jenkins, CircleCI, or Azure DevOps to orchestrate the CI process. Configure the pipeline to run unit tests, static code analysis, and other quality checks.

When creating pull requests, use templates or provide detailed notes. Clear communication helps reviewers understand the context and purpose of the changes.

Provide meaningful commit messages that explain the purpose of each change. Clear annotations facilitate collaboration and enhance transparency.

Continuously evaluate and improve CI/CD processes based on feedback and metrics. Conduct retrospectives after each deployment to identify areas for improvement and implement changes accordingly. Foster a culture of collaboration and learning within the development team to drive continuous improvement.

Follow a standard naming convention for feature branches to maintain clarity. This helps developers understand the purpose of each branch and promotes collaboration.

Monitoring and Logging

Implement monitoring and logging solutions to track the performance and health of Salesforce instances. Utilize Salesforce’s Event Monitoring or third-party monitoring tools to monitor API usage, performance metrics, and user activity. Set up alerts for anomalies and errors to proactively identify issues.

Security and Compliance 

Ensure that CI/CD processes comply with security best practices and regulatory requirements. Implement security scanning tools to identify vulnerabilities in custom code and configurations. Encrypt sensitive data and credentials used in CI/CD pipelines and enforce access controls to protect sensitive information.

Remember that CI/CD practices save time and lead to better-quality releases, reduced risks, and increased agility. By adopting these best practices, you can optimize your Salesforce development process and deliver high-quality work to end-users efficiently.

How can QC help?

QC can help with the three leading solutions for CI/CD: 

Source Driven 

Live Check Quality for Salesforce – Visual Studio Code extension

The quality Clouds Visual Studio Code plugin (Live Check Quality for Salesforce) enables a complete Shift left approach that detects issues in real-time while implementing. You can check for and apply coding best practices for every file you work on. 


Quality Clouds can be integrated at repository level using Buildcheck functionality.

Build Check for Salesforce enables you to scan your code against three levels of controls: Salesforce best practices, industry standards, and Quality Clouds own recommendations. It helps you optimize the automation of your continuous quality and release management with centralized quality gates applied in Repositories

Quality Clouds Copado Integration

Quality Clouds functionalities can be fully integrated with Copado to build quality in your continuous integration pipeline. All the commits for all your user stories can then be checked for adherence to coding standards and best practices.

Quality Clouds DevOps Center Integration

As mentioned above, Quality Clouds can be integrated with DevOps Center. This enables Quality Clouds to feature branch scan functionality at the work item level to ensure coding best practices are followed.


Implementing an agile CI/CD process in Salesforce is a strategic investment that pays dividends in faster releases, higher quality deployments, and improved team productivity. By carefully planning your approach, selecting the right tools, and adhering to best practices, you can create a CI/CD pipeline that propels your Salesforce development forward in an agile and efficient manner. Remember, the goal of CI/CD is not just to automate the release process but to enable your team to deliver value to users continuously and confidently.

Interested in what we do?
Find out how Quality Clouds can enhance your SaaS platforms' governance, compliance, and quality in real-time.
Francisco J Mejías
Francisco Javier Mejias a Senior Software Engineer at Quality Clouds with over 15 years of experience in the software development industry. He started in the Salesforce ecosystem over 6 years ago, working on implementation projects for businesses of all sizes and across all Salesforce clouds. He holds 4 Salesforce certifications focused on development and architecture.

Want to learn more? Let's talk: