Getting started with Git for Salesforce: my journey to DevOps success

Salesforce deployments can be notoriously complex and error-prone, especially when relying on traditional methods like manual change sets. As a Salesforce admin who has navigated these challenges, Eric Kenney discovered that integrating Git and structured DevOps practices can significantly streamline the deployment process and enhance team efficiency. In this article, Eric outlines the common deployment challenges Salesforce teams face, explains how adopting Git and DevOps can address these issues, and shares practical, actionable steps for implementing these processes effectively.

Understanding the deployment challenges

Before our transition to Git, our deployments regularly took up to six hours, filled with manual interventions and frequent rollbacks. The traditional deployment model posed several challenges:

• Poor visibility: Tracking changes across multiple sandboxes was cumbersome, leading to frequent deployment conflicts.
• Manual intervention errors: Manual deployment steps increased the likelihood of errors, particularly with profiles, layouts, and flow configurations.
• Complex cascading changes: Even simple metadata updates, such as picklists, could cause unforeseen cascading changes, complicating deployments.
• Time-consuming processes: Manual deployments demanded excessive time and effort, reducing our overall productivity.

How I got started with Git for Salesforce

After extensive research and exploring resources, we realized that Git and DevOps were essential to overcoming these challenges. Initially, navigating this new territory with unfamiliar terms like branches, CI/CD, and pipelines was daunting. However, structured resources provided us with the foundation needed to make this significant shift.

When first exploring Git and DevOps, I discovered DevOps Launchpad. Their structured, module-based approach felt familiar and approachable, much like Salesforce’s Trailhead. It helped me quickly grasp fundamental Git and DevOps concepts by breaking down complex terminology into digestible lessons, complete with quizzes and practical examples. This clarity allowed my team and me to confidently apply these new practices, transforming our deployment process in just a few weeks.

I learned that Git provides a clear, version-controlled record of every metadata change, offering unprecedented transparency into deployments. Meanwhile, adopting DevOps best practices — such as continuous integration, automation, and observability — could drastically reduce errors and increase efficiency for our team.

By mastering foundational concepts such as branching strategies, source tracking, and automated deployments through DevOps Launchpad, my team and I were empowered to tackle Salesforce deployments with greater confidence and efficiency. Equipped with this theoretical knowledge, we were ready to put key DevOps best practices into action, leading to tangible improvements in our workflows. Here are some actionable steps you can take to successfully start your own Git and DevOps journey, as well as what adopting these key concepts meant for our team.

Practical steps to adopt Git for Salesforce

Here is a straightforward guide based on our team’s successful implementation:

1. Set up your Dev Hub

• Enable Salesforce Dev Hub to better manage and track your sandboxes.
• Refresh or create dedicated developer sandboxes to ensure accurate source tracking.

2. Establish source tracking

• Clearly record and compare metadata changes by tracking sandbox states via Git.

3. Create and structure your Git repository

• Begin with frequently changed metadata (e.g., objects, flows, page layouts).
• Gradually expand your repository as familiarity and needs grow.
• Keep it simple to start with. You can always add complexity once you’ve built a strong foundation.

4. Implement a straightforward branching strategy

• Initially use basic branches (main/master and development), expanding complexity as necessary.

5. Integrate your ticketing system

• Link task management tools (like Jira or Asana) to your Git environment to automatically document and track changes efficiently.

Transformative results for my team

After adopting Git and DevOps practices, our team experienced remarkable improvements:

• Deployment efficiency: Reduced deployment time dramatically, from several hours to around 20 minutes.
• Fewer deployment errors: Enhanced tracking and automation minimized rollback incidents significantly.
• Improved collaboration: Git’s built-in conflict management improved team communication and streamlined deployments.
• Enhanced visibility: Source tracking provided greater transparency, leading to smoother and more predictable deployments.

Key lessons and recommendations

Based on our experience, I recommend the following to Salesforce teams considering Git and DevOps:

• Start small: Gradually scale your approach to reduce complexity and foster successful adoption.
• Educate your team: Use structured, vendor-neutral resources like DevOps Launchpad to train your team and develop essential knowledge.
• Encourage collaborative adoption: Engage your entire team early to facilitate a smooth transition and widespread adoption of a DevOps culture.

By following these steps, our team successfully transitioned to a fully integrated Git and DevOps model in about a month.

Ready to elevate your Salesforce deployments?

If you're looking to transform your Salesforce deployment process and achieve similar results, I encourage you to watch my full webinar recording for more insights and lessons learned.

To further strengthen your Git knowledge, explore the Version control fundamentals and Git branching strategies courses on DevOps Launchpad.

Or for a deeper dive into the benefits of Git and source-driven development, including practical advice for implementing version control in your business, download Gearset’s free Version control for Salesforce whitepaper.