GitHub and Salesforce are applications used by development and sales teams to manage their work and workflows better. These teams will benefit from automatically exchanging information through a GitHub Salesforce integration in order to have access to consistent and up-to-date business data.
In this guide, we will see how teams and organizations can benefit from GitHub Salesforce integration. We will also have a look at what factors to consider while choosing an integration technology.
We’ll then study a step-by-step approach for implementing this integration. And lastly, we have a look at the most common use cases of a Salesforce GitHub integration.
Note: For this guide, we are using an integration tool called Exalate. We will learn more about it as we proceed.
Get the GitHub Salesforce Integration Guide
Learn how to integrate GitHub and Salesforce, step-by-step.
Why Set up a GitHub Salesforce Integration in the First Place
GitHub is an online source code management and version control platform. It helps developers consolidate their codes to maintain a consistent version that all the team members can access and track.
Salesforce is a CRM tool that supports the entire sales workflow, from lead generation to post-sales support. Sales teams widely use it to have a complete overview of customers.
Accounts, Products, Opportunities, Tasks, and Cases are Salesforce entities that cater to different customer-centric tasks through a single interface.
Why Integrate GitHub and Salesforce?
Enhanced customer support and better resolution of queries are significant factors in keeping existing customers happier and maintaining a low churn. To achieve this common goal, teams in an organization strive hard to search for the information they need in different applications or ask other team members for it.
But this way of doing things is manual. Teams either ask for information through phone calls or emails, or get in endless meetings to gather the relevant details they need, or spend time copy-pasting information by toggling between different applications.
This results in manual data entry mistakes, redundant, misplaced, or altered information, and, above all, a great deal of wasted productive time.
Automated information exchange with the help of a cross-company integration tool can help teams maintain a single, consistent view of business-critical information without having to leave their current platform of choice.
So if your teams use Salesforce and GitHub, then an automatic, real-time data exchange through a GitHub Salesforce integration can help them deliver a better customer experience and allow them to collaborate harmoniously with each other.
Choosing the Right Technology for a GitHub Salesforce Integration
Implementing a GitHub Salesforce integration requires researching different tools and technologies and choosing the right one based on your business needs.
Here are a few drivers to get you started.
Decentralized Integration
A tool having a decentralized integration must be your top choice. This is because it will allow you the autonomy to work in your environment independently without having to consult the other side. This lets you control what information you send and how you want to receive it. So, each side has independent information exchange rules.
Security
Data is of paramount importance for any business. So when you want to exchange it, you must be careful to put the correct security measures in place.
Also, the tool should support encrypted file transfers, access control mechanisms, and secure transfer protocols like HTTPS.
Flexibility
Integrations mature and change with time. So do your requirements for sending and receiving information. Sometimes, you want to share something extra, or you want to stop sharing some data.
Here, you need to acknowledge how the tool adapts to these changing requirements beforehand. Accommodating unique and advanced business integration use cases with minimal configurations must be an inherent feature of the integration tool you choose.
Reliability
Computer systems are prone to downtimes and failures. In such situations, your tool must be able to withstand the downtime and apply the changes queued for synchronization in the same manner as they had originated. All this should happen automatically so the integration parties don’t feel that there was anything wrong in the first place.
Number of Integrations Supported
We are discussing a GitHub Salesforce integration here, but it’s just one single possibility amongst many others. You might have partners, suppliers, customers, or MSPs who use different applications like Jira, Azure DevOps, ServiceNow, Zendesk, and the like. Adopting a tool that already supports these integrations is an added advantage.
There are a lot of integration tools in the market, but for this article, I have chosen Exalate.
This is because it has an inbuilt decentralized integration architecture, ensured with the help of sync rules on both sides. Plus, it uses security measures like encrypted file exchange and role-based access controls. Check this security whitepaper for further details.
Exalate also comes with a scripting mode that uses Groovy scripting, in addition to a low-code UI mode, suitable for both business and technical users. This helps you adapt it to your specific integration needs easily.
It has a transactional synchronization engine that queues all the applicable changes automatically and breaks them down into atomic steps, to be retried in case of a failure, even when a system is being upgraded to a new version and/or a firewall is being reconfigured.
And last but not least, it supports integrations for a variety of applications like Jira (cloud and on-premise), ServiceNow, Azure DevOps, Zendesk, and others.
So let’s get to implementing a GitHub Salesforce integration.
How to Set up a GitHub Salesforce Integration: the Step-by-Step Process
To start setting up a GitHub Salesforce integration, you must first install Exalate on both GitHub and Salesforce. This ensures you have autonomy since the Exalate app on both sides allows you to configure each side separately and helps you control what to send and deliver.
After that, you can set up a connection, configure it, add automatic synchronization triggers, and experience 2-way sync to handle your synchronization needs effectively.
So let’s get started!
Step 1: Install Exalate on GitHub
First, log in to your GitHub account.
Click on “Marketplace”. Type “Exalate”. Or save some time by clicking on this link instead.
Note: Exalate is also available for GitHub Enterprise. For installing Exalate on GitHub Enterprise Cloud, check this article.
You can use Exalate on GitHub with the 30-day free trial.
To proceed with it, click on the green “Set up a plan” button. Then click the “Install it for free” box.
Then you will receive a prompt to give Exalate permission to access your GitHub repositories. You can choose to give access to all of them or select specific ones only.
It is important to note here, that Exalate does not access the GitHub code, but only has access to metadata, issues, and pull requests.
Select the permissions you want to give and click “Install”.
You will then be redirected to the Exalate site to accept the user agreement to continue.
Next, you need to select how Exalate accesses your GitHub account, either by an OAuth token or by entering your GitHub account username and password. In case you want to regenerate your OAuth token, follow these steps.
You will then need to request an evaluation license for using Exalate on GitHub. The steps for this are pretty straightforward.
Note: You will not be able to synchronize your issues without requesting the evaluation license.
Step 2: Install Exalate on Salesforce
Note: Exalate accesses Salesforce through APIs. Salesforce has its own guidelines for API Access add-ons. For instance, API access is provided by default in Enterprise accounts, but it’s not the case with other accounts like Professional. Visit this documentation page to learn about the different Salesforce editions Exalate supports.
To install Exalate on Salesforce, begin by visiting the Salesforce AppExchange and searching for Exalate. Once you find it, click the “Get it Now” button.
You will then need to choose where to install Salesforce: either “Install in This Org” or in a Sandbox org. I opted for the former.
Scroll down to the bottom of the screen and agree to the terms and conditions, then press “Confirm and Install”.
Next, select the users for whom you want to install Salesforce; you can always modify this later. In my case, I chose “Install for All Users” and click “Install”.
After that, “Approve Third-party Access” and click “Continue”. The installation process will be completed. To finish, click on “Done”.
Now, navigate to your Salesforce instance and create a connected app. Make sure to save the “Consumer Secret” and “Consumer Key” provided. Then, within your Salesforce instance, locate “Apps” and search for “Exalate”.
For requesting an Exalate node, enter the previously saved “Consumer Secret” and “Consumer Key” and click “Request Node”. You will be prompted to click “Allow” to grant access permissions to Exalate.
Proceed by providing your personal details and click “Agree and Submit” to await an email from the Exalate License Manager.
Once received, open the email and click “Verify Exalate instance”, which will redirect you to the Exalate admin console.
From this point, you can proceed to establish a connection between GitHub and Salesforce.
If you ever get logged out of your Salesforce instance, just follow these steps to log in again.
Step 3: Establish a Salesforce GitHub Connection
Now it’s time to set up your connection!
With Exalate, one side initiates the connection, and the other side accepts it. After setting up the connection, you can proceed with configuring it to start sending information back and forth.
This is an important first step if you want to start synchronizing GitHub issues and Salesforce entities.
Say you want Cases to fire up new Issues in GitHub. Or trigger dev issues/product updates directly from Salesforce to GitHub. Whatever the case is, we will see how to do that in the next few steps.
After installing the Exalate app, you should be redirected to a welcome screen.
From there, you can navigate to the “Connections” tab in the left-hand menu.
Connections in Exalate define how your synchronization behaves. It includes what information you want to send and receive and includes other configuration details.
With Exalate, you can initiate the connection from either the GitHub side or the Salesforce side. The UI for all the Exalate screens is the same, so it doesn’t matter which side you start with.
For this guide, let’s start from the GitHub side.
Click the green “Initiate Connection” button to start setting up the connection process.
Then, you will need to enter the destination URL — your Salesforce URL. You can copy it by going to “Getting Started” on the left-hand Exalate menu.
After this, Exalate performs a quick check to see if it is installed on the destination instance or not. It will send appropriate messages while it does this.
More fields will appear, asking you to choose the configuration mode you want for the connection.
Exalate provides 2 such modes: the Basic mode and the Script mode.
The Basic mode has default mappings of different Salesforce entities and Github issues. You can’t change them. It has an intuitive UI and you can start your synchronization immediately with this mode. It is suitable for use cases of basic complexity.
Note: With the Free Plan, you can set up a connection in the Basic mode, allowing you up to 1000 free syncs per month. You can get started here.
The Script mode has advanced configurations, customizable mappings, and features. With this mode, you can change the existing mappings, configure new ones, and control what and how you want the information to go over to the other side. It allows you to sync almost any Salesforce entity with GitHub issues, the way you want to. This kind of customization allows you to adapt Exalate to use cases of advanced complexity.
We recommend you try this mode since it allows you to customize your synchronization and use Exalate’s full functionality.
You can choose to upgrade the Basic connection in Salesforce or Github and move to the script mode anytime you want.
We will have a look at both modes one by one.
Continue with the Basic mode
Once you select “Basic” on the screen above, click “Next”.
You need to select the repository whose issues you want to sync on the Salesforce side. Select one from the dropdown list. Click “Next” when you are ready.
You will then be asked to verify admin access to the destination instance. In our case, that’s Salesforce. Click “Yes, I have admin access” if you have it, otherwise click on “No, I don’t have admin access”. The latter approach will generate an invitation code that you will need to copy and paste on the other instance.
Since I have access, I click on yes and hit “Initiate”.
After a quick verification, you will be redirected to the destination side (Salesforce).
The Basic connection allows you to start synchronization immediately. You can enter the Case key you want to sync, hit “Exalate”, and you are good to go.
Note: The Case number entered above comes from the URL of the Case you want to sync as shown in the image below.
On the GitHub side, the same Exalate screen will prompt you to enter the issue key.
Note: On the GitHub side, the same screens will be displayed but will be specific to issues.
In case you don’t want to “Exalate” your Case immediately, you can choose to press the close button on the screen above and use the trigger option to create automatic syncs to the other side or use the ”Bulk Connect” option to sync Cases in bulk.
We will cover how to create triggers in step 5. Meanwhile, you can learn more about “Bulk Connect”.
Once you Exalate the Case, it takes a while for the sync to complete.
And finally! You’ve synced your first case. You can also sync the subject, comments, status, and description for this Case automatically.
To go to the remote issue created on the GitHub side, click on the link generated for the issue (8 in our case). To refer to the Salesforce Case, click on the link below it.
Continue with the Script mode
Moving to the Script mode, press “Next” on the screen after you select “Script”.
You now need to name the connection.
For this, enter the local instance name (GitHub). This is the side you initiate the connection from. Then enter the remote instance name (Salesforce). This is the destination side name.
Exalate then generates an automatic connection name for you. But you can edit it if you want.
Give your connection a description as well. This will be helpful when you have a list of them.
After finalizing all this, click “Next”.
Choose the repository you need to sync issues from on the GitHub instance. Select the correct one from the drop-down list. Click “Initiate”.
Now an invitation code appears.
This code is a unique secret that allows you to form a connection with the other side. You simply need to copy and paste it.
So click on “Copy invitation code” and save the copied code somewhere handy.
Your work on the GitHub side is over for now. Then open your Exalate console on Salesforce.
And navigate to the “Connections” tab on the left side and click on the “Accept Invitation” button.
The code you had copied, now needs to go in the text box. After pasting it, click “Next”.
Now you’ve successfully established a GitHub Salesforce connection. You can continue to configure your connection next.
You can do this in two ways: either by clicking the “Configure Sync” button shown on the screen below or by editing the connection to configure it. We will see how to do this in detail in step 4.
Step 4: Configure the Connection to Decide What Information is Shared
If you have followed the steps sequentially, you will now be redirected to the following screen.
This screen allows you to configure the connection to control what information is shared with the other side and how you want to interpret the incoming information. Maybe you want to map the issue summary in GitHub as an internal comment under a Case in Salesforce or you may want to sync all open issues on GitHub to Cases in Salesforce.
All of this can be done by configuring the connection. We will get to a detailed explanation of this screen shortly.
Meanwhile, as I mentioned earlier, you can configure the connection by clicking on the edit connection button as well. The connection you created earlier can be viewed under the “Connections” tab.
This tab specifies all the connections you have created as a list, with different options for each connection given next to their names. Every connection has a status that shows the connection being “Active”, “Pending”, “Error” or “Deactivated”.
You can also see the number of issues under sync and the last synced time here.
The edit connection button shown in the image below allows you to configure the connection
There is a remote antenna button that takes you to the other side. Clicking the 3 dots allows you to activate, deactivate, or delete the connection. You can even “Exalate” a single issue or a Case here.
Let’s move back to our configuration screen. Just so you are not lost, this is how it looks on the Salesforce side.
And the Github side
As seen above, the UI is the same, just the scripts have changed. We will see what the scripts are in a minute.
The screen has 4 tabs: “Rules”, “Triggers”, “Statistics” and “Info”.
We will cover “Triggers” in step 5.
The “Statistics” tab gives an overview of the synchronization information about the number of issues under synchronization, the last sync date, etc.
The “Info” tab provides a general description of the connection, stating its name, destination URL, description, and type.
The “Rules” tab has scripts written in Groovy Scripting language. These are sync rules that specify what information should be sent to the other side in the “Outgoing sync” rules, and map the information coming from the other side in the “Incoming sync” rules.
Both the outgoing and incoming sync rules are present on the Salesforce and GitHub sides as shown above.
You can alter the sync rules using scripts anytime you want. Alteration means editing the
- outgoing sync rules by
- not sending existing information anymore by deleting the rule
- sending new information by adding scripts
- incoming sync rules by
- not receiving some information anymore by deleting the rule
- receiving new information by adding scripts
You can decide to not send or receive certain information by deleting or commenting on a particular line (read the rule) from the text box shown above.
Commenting means the particular line will be ignored at the time of synchronization. To comment, simply add a “//” at the start of the line. To remove multiple rules, add “/*” at the start of the block of lines and then “*/” whenever you want to end.
For instance, if you don’t want to send a description of the Case from Salesforce to Github, you add “//” as follows: //replica.description = entity.Description.
Sometimes you want to send or receive additional information. This is when you add new scripts in the outgoing and incoming syncs.
For instance, if you want to sync “Task” in Salesforce in addition to “Case”, you add the following script in the outgoing sync box.
if(entity.entityType == "Task") {
replica.key = entity.Id
replica.summary = entity.Subject
replica.description = entity.Description
}There are countless possibilities in the way you can edit these script rules to suit your specific use case. So experiment as much as you want!
You can always refer to Exalate docs for GitHub and Salesforce to learn more about how to work with them.
Move on to creating triggers.
Step 5: Set up Automatic Synchronization Triggers to Share Information
Rules define what you want to send to or receive from the other side, but triggers define how you want to start the synchronization process.
They allow you to specify under what conditions you want the synchronization to happen.
For instance, when the sales team logs a feature request raised by an important customer under a Case in Salesforce, an issue is automatically created in GitHub.
Such and many other conditions can be set under the search query, and if the condition is met then the trigger automatically starts synchronization based on the outgoing and incoming sync rules you have set.
For this, click the “Triggers” tab.
This tab shows a list of all the triggers you have created.
If this is your first time, the list is empty. Click “Create trigger”.
An “Add trigger” screen pops up.
Note: You can also create triggers by clicking on the “Triggers” tab in the left-hand Exalate menu. When you choose this option, you need to additionally choose the connection name you want to execute the trigger for.
The “Add trigger” screen first asks you to select an entity type. I have selected an “issue” type here since the screen is for GitHub. We will see how the Salesforce screen looks, shortly.
Under the “If” section, enter the search query.
These search queries are platform-specific. Here, we are syncing all the issues with the status as open.
To know more about GitHub search queries visit this page. For Salesforce, Exalate uses the SOQL (Salesforce Object Query Language) syntax. Learn more about it here.
Add appropriate notes to help you understand why you have created this trigger.
Click the “Activate trigger” checkbox to activate or deactivate the trigger. This saves you time when you don’t want to create a trigger from scratch but don’t need to use it right now.
Click “Add” once you are done.
On the Salesforce side, let’s have a glimpse of what the add triggers screen looks like.
There are many entity types supported by Exalate. But the most popular ones are Opportunity, Product, Account, Case, and Task.
After you select Opportunity as the Salesforce entity type, you select conditions to filter entities for setting the trigger.
Enter the search query with the toggle button as shown below.
You can learn more about how this is done on the Salesforce and the GitHub side if you want.
You can see the created trigger listed as follows. If you want, you can choose to edit or delete the trigger from here.
By clicking the 3 dots next to the trigger you can choose to “Bulk Exalate” all the current issues or entities fitting the search criteria.
Don’t forget to click “Publish” when you have finished making the changes.
Common Use Cases
The most plausible use case that can be supported by a GitHub Salesforce integration is enabling seamless collaboration between sales and development teams.
Sales teams get a lot of customer queries, feedback, and new feature requests. An integration solution like Exalate can allow them to fire these customer concerns into GitHub right from within Salesforce. This will create an issue in GitHub. The issue progress and the appropriate status updates can then be viewed by the sales team from the Salesforce UI. And they are in a better position to update their customers on the status of the issue.
Important product updates or feature request issues undertaken by the development teams in GitHub can be automated and synchronized with Salesforce entities. So the sales team always has the most recent and up-to-date product information ready to be taken up with their customers who have been waiting for exactly that update or feature.
Conclusion
We saw how a GitHub Salesforce integration can help sales and development teams collaborate and share business-critical information to help them enhance customer experience.
We also discussed how choosing the right technology for your integration can manifold the benefits such integration can bring along. Every organization has its drivers for choosing an integration tool, but we chose Exalate since it checks most of our criteria.
Finally, we covered a step-by-step approach to implementing a GitHub Salesforce integration to ensure that the integration is handled systematically.
Frequently Asked Questions
What is a GitHub Salesforce integration?
A GitHub Salesforce integration is a way to connect your GitHub repository with a Salesforce Org. Such an integration will enable seamless collaboration between the business teams using Salesforce and the developers using GitHub.
How does GitHub integrate with Salesforce?
GitHub can integrate with Salesforce by providing a version control and collaboration platform on Salesforce projects. You can connect your Salesforce Org to a GitHub repository and use Git to manage changes to Salesforce metadata and code.
How do I deploy changes from GitHub to Salesforce?
You can use tools like Salesforce CLI or third-party integration solutions like Exalate to facilitate the deployment process from your GitHub repository to Salesforce.
What tool can I use to integrate GitHub and Salesforce?
You can use third-party tools like Exalate to integrate GitHub and Salesforce. This solution allows you to create custom scripts to tailor the integration to your specific requirements. So you can integrate any Salesforce objects into GitHub repositories.
Can I integrate GitHub and Salesforce for free?
Yes, you can integrate GitHub and Salesforce for free. Both these platforms offer free plans to connect. But only the core integration with basic features is free. Additional integration requirements may have associated costs. You can try other third-party tools that have various integration options at a fair price.
Recommended Reads:
- How to set up a Jira Salesforce Integration
- Salesforce to Salesforce Integration: Sync Multiple Salesforce Instances Bidirectionally
- How to Set up a Jira GitHub Integration
- Salesforce Zendesk Integration
- How to Set up a ServiceNow GitHub Integration
- How to Set Up a Salesforce ServiceNow Integration
- How to Set up an Azure DevOps GitHub Integration
- How to Set up a Zendesk GitHub Integration
