GitHub Salesforce Integration: How to Set up a Sync in 6 Steps

GitHub Salesforce integration

GitHub and Salesforce are among the most popular applications used by development and sales teams. These applications can help teams manage their work and workflows in a better manner. But these teams will benefit from the information being exchanged automatically between them in order to have access to consistent and up-to-date business data. A GitHub Salesforce integration can help teams share and sync information in such a manner. 

In this guide, we will see how these teams can benefit from a Github Salesforce integration. We will also have a look at what factors to consider while choosing an integration technology. We then move ahead and 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.

An overview of what is covered in this blog post:

Note: For this guide, we are using an integration tool called Exalate. We will learn more about it as we proceed. 

Why Set up a Github Salesforce Integration in the First Place

GitHub

Github is an online source code management and versioning platform. It helps developers consolidate and collaborate their codes to maintain a consistent version that can be accessed and tracked by all the team members.

It is popular among the open-source community. It also supports issues that are worked on until resolved so developers can monitor and keep track of their progress. 

Salesforce

Salesforce is a CRM tool that supports the entire sales workflow, right from lead generation to post-sales support. It is widely used by sales teams to have a complete overview of customers. 

Accounts, Products, Opportunities, Tasks, Cases are popular Salesforce entities that cater to different customer-centric tasks through a single Salesforce interface. 

Why Integrate GitHub and Salesforce?

It’s a known fact that enhanced customer support and better resolution of their queries is a major factor to keep existing customers happier and maintain a low churn. So, 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. 

All this leads to manual data entry mistakes, redundant, misplaced, or altered information, and above all wastes a lot of 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 

However, implementing a GitHub Salesforce integration is not as easy as it sounds. 

It requires researching different tools and technologies that offer such integration and choosing the right one based on your business needs. 

Here are a few drivers to help you get 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, care must be taken that it’s done with correct security measures in place. 

Encrypted file transfers, access control mechanisms, and secure transfer protocols like HTTPS, etc should be inherently supported by the tool.  

Flexibility

Integrations mature and change with time. So do your requirements of sending and receiving information. Sometimes you want to share something extra, or you want to stop sharing some data. 

Here, how the tool adapts to these changing requirements must be acknowledged 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 be able to 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 vendors 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 changes that need to be applied 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 the least, it supports integrations for a variety of applications like Jira (cloud and on-premise), ServiceNow, Azure DevOps, Zendesk, and HP QC/ALM. 

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 can be sent and received. 

After that, you set up a connection between them, configure it, create automatic synchronization triggers, and experience 2-way sync to effectively handle your synchronization needs for you. 

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.  

exalate for github

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. 

exalate for github issue sync

Then you will be asked 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”.

exalate for GitHub repository

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

Currently, you can access Exalate for Salesforce through its EAP (Early Access Program) only. It will be available on AppExchange soon. 

To begin, you have to configure Exalate on your Salesforce instance. The step-by-step procedure is given here, so you can refer to it.

On your Salesforce interface, click on the Settings icon on the top right of your screen and select “Setup”.

salesforce setup

On the left menu, you will find “Apps”. Click on it and then go to “Apps Manager”. On the right side of the screen, click on “New Connected App”. 

salesforce app manager

Fill in the required details for the Exalate app on this form.

salesforce new connected app

On the same form, move down and click on “Enable OAuth Settings”. Provide a callback URL for the EAP.

Then you need to add the necessary OAuth Scopes. To do this, select the scopes shown below and add them with the help of the “Add” arrow button. 

Scroll up and hit the “Save” button once done. 

Salesforce API

Quickly perform a check for the OAuth policies of your connected app. Go to the left-side menu, click Apps> Connected Apps> Manage Connected Apps, and then select “Exalate”. Ensure the “Permitted users” is set to “All users may self-authorize” and if it’s not, follow these steps to get it done.

Now to request an evaluation license of Exalate for Salesforce(EAP), go to this page, select Salesforce as your tracker.

Salesforce integration page on Exalate

A form appears. For some fields of the form, you need to gather details from your Salesforce instance.

Form for requesting Salesforce integration

So let’s head back there!

Navigate to “App Manager” just like you did a while ago. Search for your newly connected app, “Exalate” in our case. On the right side of the app name, click on the down arrow and select “View”. 

salesforce lightning app manager

From here, copy the “Consumer Key” and the “Consumer Secret” and keep it somewhere safe. We will need them for filling in the form.

manage connected apps in salesforce

Then you need the Salesforce tracker URL. But note that for Exalate, you need the Salesforce URL of the Classic version. So if you are in the Lightening edition, click on the profile icon on the top right of the screen and choose “Switch to Salesforce Classic”. It will redirect you to the classic version and you can copy the URL from there. 

salesforce classic

Now you go to the form and enter the “Customer key” and the “Customer secret” along with the Salesforce URL that you have kept handy. Then choose the “Organization type”, we have selected “Production” here. In case you are confused, visit this page. Then click “Submit”.

Exalate then sends out your Salesforce instance in your email. So go there and click on the link provided.

Allow access to Salesforce.

Allow access Jira Salesforce integration

Another form for your email and other personal details will appear. Fill them in so Exalate can verify your instance and activate an evaluation license.

Exalate for Salesforce

Click “Agree and Submit”, accept the EULA and then follow the link in your email for verifying the instance. After a successful verification, the following screen will be displayed.

exalate for salesforce email validation

You might also need to generate your login credentials for logging into Exalate for Salesforce. Learn how to do it here.

After installing Exalate on both GitHub and Salesforce you proceed to the next step. 

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. Once the connection is established, 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 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 the purpose of our guide, we start with the GitHub side. 

If this is your first time setting up a connection, the screen below should be blank, otherwise, it has all your connections listed. Click the green “Initiate Connection” button to start setting up the connection process. 

initiate a GitHub salesforce integration

Then you will need to enter the destination URL. Here, it means your Salesforce URL. You can copy the URL, by going to the “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. 

After some time, more fields will appear asking you to choose the configuration mode you want for the connection. 

exalate configuration modes

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. These cannot be changed. 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 and configure new ones, control what and how you want the information to be passed 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 out since it allows you to handle your synchronization the way you want and use the full functionality of Exalate. 

You can choose to upgrade the Basic connection in Salesforce or in Github and move to the script mode anytime you want.

We will have a look at both the 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. 

initiate GitHub salesforce sync

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”. 

exalate admin access

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. 

successful GitHub salesforce basic connection

Note: The Case number entered above is fetched 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 it to be synced. 

GitHub salesforce integration in progress

And finally! Your first Case has been synced. Subject, comments, status, and description for this Case can automatically be synced. 

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. 

successful Salesforce Github sync

Continue with the Script mode

Moving to the Script mode, press “Next” on the screen after you select “Script”. 

exalate script mode

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 you are done finalizing all this, click “Next”.

initiate GitHub salesforce integration in script mode

Choose the repository you need to sync issues from on the GitHub instance. Select the correct one from the drop-down list. Click “Initiate”.

sync github to salesforce

Now an invitation code is generated. 

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. 

exalate invitation code

Your work on the GitHub side is over for now. You can go to the Salesforce side by clicking “Go to remote” or you can simply open up your Exalate console on Salesforce. 

Any way you plan to do this, navigate to the “Connections” tab on the left side and click on the “Accept Invitation” button. 

exalate connection list

The code you had copied, now needs to go in the text box. After pasting it, click “Next”.

paste exalate invitation code

Now your GitHub Salesforce connection has been successfully established. You can continue to configure your connection next. 

This can be done in 2 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 this is done in detail in step 4. 

configure GitHub salesforce sync

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 the detailed explanation of this screen shortly.

GitHub salesforce sync rules

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 like 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. 

edit Salesforce Github connection

Let’s move back to our configuration screen. Just so you are not lost, this is how it looks on the Salesforce side. 

Salesforce Github sync rules

And the Github side

GitHub salesforce sync rules

As seen above, the UI is the same, just the scripts have changed. We will see what 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

  1. outgoing sync rules by
    1. not sending existing information anymore by deleting the rule 
    2. sending new information by adding scripts
  1. incoming sync rules by
    1. not receiving some information anymore by deleting the rule 
    2. receiving new information by adding scripts

You can decide to not send or receive certain information by deleting or commenting a particular line (read 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 starting 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.

salesforce GitHub integration outgoing sync

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

GitHub salesforce integration outgoing sync

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. 

Toggle the “Active” switch to activate or deactivate the trigger. This saves your 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. 

add trigger to GitHub salesforce sync

On the Salesforce side, let’s have a glimpse of how 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.

create triggers in salesforce github integration

You can also enter the search query with the toggle button as shown below. 

search query Salesforce GitHub sync

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. 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. 

GitHub to salesforce integration triggers

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 definitely help sales and development teams collaborate and share business-critical information with each other 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 own drivers for choosing an integration tool, but we chose Exalate since it checks most of our criteria. 

And finally, we covered a step-by-step approach to implementing a GitHub Salesforce integration to ensure that the integration is handled systematically. 

Recommended Reads:

Comments are closed.