Exalate or Getint: An Objective Comparison to Help You Choose the Best Integration Solution

Integration solutions form an important part of your technology stack and often play a critical role in most businesses. 

Today, we decided to compare two popular integration solutions: Getint and Exalate. 

It’s important to get a clear, transparent, and unbiased perspective when it comes to comparisons. 

So in this blog post, we compare their main features, pricing, licensing, etc., to help you make an informed decision. 

Let’s get started. 

Getint: An Introduction

Getint is a synchronization app for platforms like Jira, Azure DevOps, Salesforce, Asana, etc. It allows both one-way and two-way synchronization. Though primarily a Jira app, it also comes as a standalone platform that is available both as a SaaS and on-premise solution. 

Exalate: An Introduction

Exalate is an integration solution designed to connect ITSM and work management tools across different teams and companies. It allows both one-way and two-way integration while keeping each side fully autonomous. Through its scripting engine, it provides a blend of flexibility and control, giving you the freedom to manage your sync the way you want. 

Let’s delve into the features that make these solutions unique and appealing. 

Decentralized Vs. Centralized 

Exalate is a decentralized integration solution. In essence, it means each integrating side independently decides what it shares and doesn’t share with the other side. 

We kept the architecture decentralized to ensure additional security. Such an integration will help you restrict access to shared data accidentally or on purpose. This setup is especially beneficial for companies that wish to sync with external providers, suppliers, or customers without having to contact them for every single change in the integration process. 

Getint is based on a centralized interface initially designed to be used within the Jira environment. A single admin is responsible for setting up and maintaining the integration mappings and configurations. Although this can be easier for an intra-company setup, it is purely exhausting for a cross-company scenario. 

The Bottom Line: While a centralized interface is more common and familiar and, therefore, may seem simpler,  decentralized integration increases security and is ideal for cross-company integrations. 

Platforms Supported

Getint supports different platforms like Jira, Salesforce, Asana, monday.com, ServiceNow, etc. 

Exalate supports fewer platforms than Getint but has a much wider integration scope and possibilities. It provides integrations for Jira, ServiceNow, Salesforce, Azure DevOps, Zendesk, GitHub, etc. 

Getint can be deployed either as a SaaS (Software as a service) or on-premise and can work as a standalone application behind the firewall. 

Exalate can be deployed on the cloud for all the systems, but you can also choose to deploy it on docker for all the supported platforms, depending on your security requirements. 

The Bottom Line: Getint has the upper hand with the number of platforms it supports. However, Exalate is a winner when it comes to the range of possible use cases, including deep integration and advanced cross-company scenarios. 

Embedded UI

We observed that with Getint, it’s not possible to view the sync status directly within the platform’s entity view. To do that, a Jira admin needs to navigate to the Getint dashboard to view it there. 

This can be frustrating for users, especially since the purpose of integration is to get the information within the tool without having to take extra steps. 

Additionally, any updates to the synced entity are reflected only upon refreshing the screen, forcing users to perform an additional step. 

Exalate has an embedded UI for platforms like Jira, Azure DevOps, Salesforce, and Zendesk. This makes it easy to view the sync information right within the entity view. It’s also easy to view the progress of the sync in the embedded UI without having to navigate to another interface. There is also a direct link to the remote synced entity within the embedded Exalate panel. 

Additionally, all updates are real-time, and if you have a good internet connection on both sides, it’s almost instant.

The Bottom Line:  Exalate can be a better option if an embedded UI and sync status visibility are important to you. 

Customization or Flexibility 

Perhaps the beauty of an integration solution is its ability to handle intricate scenarios elegantly and effortlessly. 

Both Exalate and Getint provide scripting capabilities for advanced use cases, but they differ in the way it is provided.

Getint’s UI is impressive in the way that it covers the most common use cases. It also supports variables and logical conditions for dynamic value construction in fields. It uses Javascript for advanced scenarios. For any additional integration configurations, you can contact their support.

However, we had our engineers look into their scripting feature and they concluded that it’s very basic and isn’t enough for advanced scenarios. So, the claim that they support advanced scenarios with scripting is questionable. 

Exalate on the other hand is built to handle complex scenarios gracefully, that’s what it does best. Its Script mode is based on Groovy scripting and is strong enough to handle any use case thrown at it. You no longer need to worry about squeezing integration requirements through the UI. 

You might feel safe with a visual interface that allows you to set your sync requirements through a drag-and-drop mechanism, but as you progress, requirements change, which means being limited to what the tool offers. If you look at this with respect to cost-effectiveness, the more the tool can do, the better will be the ROI. 

“Take your time to dive into what’s possible with Exalate. There’s so much under the hood that you could do – if you keep it simple and use defaults, it’s only 5% of what’s possible, you could build crazy and cool stuff” – Maarten Cautreels, Product Owner, DPG Media

Possibilities with Getint and Exalate: A Deep Dive

Both these solutions differ in their functionalities related to customization. We’ll cover a few of them in this section. 

• Both Getint and Exalate can sync historical data, but the bulk sync process in Getint involves far more steps than in Exalate. 
• Both these platforms can sync custom fields, comments, attachments, etc., bi-directionally.
  However, Exalate can handle certain advanced scenarios, like configuring comment syncing at a granular level. This cannot be implemented using Getint.
  Let’s understand this in detail.
  Jira Cloud and Jira on-premise handle user mentions differently. Ensuring the right user is mentioned with every sync will ensure transparency and visibility amongst teams. 
• Exalate can sync third-party plugin data like Insights, Tempo Worklogs, etc., whereas Getint cannot. 
• Getint allows syncing hierarchies in a standard manner and works for simple scenarios. Exalate allows syncing hierarchies using scripts in any way defined by the user, such as multi-level hierarchy sync between Jira and Azure DevOps.
• Since Exalate has the entire Groovy scripting capability at its disposal, there’s a lot you can build using scripts, including advanced computing and mapping logic. This cannot be said for Getint. 
• Exalate allows you to set up granular platform-specific triggers to filter entities for sync. For instance, you can use SOQL (Salesforce object query language) in Salesforce and WIQL (Work item query language) in Azure DevOps. These triggers are available independently for all integrating sides giving you better control. Filters in Getint can be set up using the UI and can be limited by the UI. 
• Getint’s bulk resync feature should be an inbuilt functionality. We failed to understand the need for this feature. According to their documentation, bulk resync is used to re-synchronize multiple records or issues across integrated platforms in one go.
  With Exalate, this feature always runs forever. 

The Bottom Line: Exalate works wonderfully for deep integrations, so if that’s your use case, it is the best choice. Plus, it provides you with the flexibility to implement any use case, no matter how complex it is. You can do almost anything with AI Assist, the AI-assisted integration feature of Script mode. 

Getint’s UI looks extensive at the onset and you can use scripts on top of their UI for added flexibility, but then again its functionality is very basic if compared with Exalate’s Script mode. 

We also performed research of our own to understand the scripting capabilities Getint claims to have but they were very modest, to say the least.  

Security

Integration security includes measures like encryption, role-based access control, use of secure transfer protocols, data privacy, and the like. 

Getint’s security measures raised some concerns for us since we could not find any reference to guaranteeing the safety of customer data at rest or in transit. 

Our internal security engineer, after reviewing their security statement, concluded that it is unlikely that the information stored is encrypted on their servers. This makes the data much more vulnerable in case of breach. 

Getint is ISO 27001 and 27018 certified. 

We also observed that the full contents of Jira issues are exposed in logs on the remote side, which can be accessed. 

Exalate has a multi-layered approach to data security and employs solid encryption protocols with security ceremonies throughout the development process. It is ISO 27001 certified.

As discussed earlier, our decentralized integration approach increases the security of the data inherently. 

Through a single-tenant architecture, Exalate helps prevent data leakage by keeping it isolated at the infrastructure level, improving security, and lowering the risk of data breaches. 

You can understand the entire Exalate security posture in this whitepaper. 

The Bottom Line: If you want peace of mind without having to worry about your data and integration security, then Exalate is a good choice. We have it all in black and white, without any room for discrepancies or doubts. 

User-friendliness

Getint has a solid visual interface that handles most of the mappings. You can use advanced scripting on top of the UI. 

We also came across some nice features in their UI, like deciding the time when the integration should be run and, for instance, excluding it on weekends.

Exalate offers three modes: Basic, Visual (BETA), and Script mode. 

Getint’s visual mapping interface might be preferred by users as it’s generally accepted that template-based or visual interfaces are more user-friendly than scripting. But Exalate champions disagree and say that they will never exchange the freedom of scripting for the best UI interface in the world. 

The Bottom Line: If your use case is standard or a slight deviation from standard, then Getint’s visual interface can be a win for you. But if you want the whole scope from simple or common to the most intricate and customized use cases, then Exalate is hands down the winner.  

Migration Vs. Integration

Getint provides an option for migration at an additional cost in addition to the integration functionality. 

Exalate is more focused on integrations rather than migrations. This is because our tool was built for advanced ongoing integrations. We can perform migrations as well because migration, in a nutshell, is a one-way sync, but we choose not to because it’s a strategic business decision for us. 

Getint does do both and in our opinion, no tool can do both perfectly. 

The Bottom Line: If you are looking for stable, fully functional, ongoing integrations, then Exalate is the right choice. If you just want one-time migrations, Getint can be the answer. 

Support

Both Exalate and Getint pride themselves on their support teams.

However, as of October 2024, Exalate has a much bigger support team consisting of 12 dedicated members covering all time zones. We also have Aida, our AI sidekick, who works 24/7 to help answer any Exalate questions you may have. 

The Bottom Line: Exalate’s support fairs well on most fronts.

Documentation, Community & Partner Network

Getint has very limited documentation and doesn’t have a community. They claim to have partners but we could not find enough substantial information regarding this.

We also came across a Getint news update where they introduce AI-enhanced documentation but couldn’t find any AI traces on their site. 

Exalate’s documentation sweeps away Getint’s by a fair margin, offering step-by-step video tutorials, proper case studies including customer names, extensive use case examples, and Aida, the AI sidekick that works as a documentation assistant. 

We also have a community that is planned to be revamped soon for deeper collaborations, peer-to-peer configuration support, and sharing best practices. Our partner network is worldwide and features stars from Atlassian solution partner programs and other ecosystems. Our partners even provide scripting-as-a-service in their respective time zones. 

We did not find enough reviews for Getint on G2, Capterra, and Trustpilot.

The Bottom Line: Exalate’s documentation & other resources are far superior to Getint. 

Pricing, Licensing, & Value

While Getint claims to offer fair pricing and shaming other vendors for asking more, it’s important to note that Exalate’s pricing is competitive and often comparable or even more affordable, especially for high-tier instances. 

Our customers say they receive excellent value for their investment while enjoying a comprehensive integration solution. Contact us for all your pricing questions.

Exalate’s licensing model requires licenses to be purchased for all integrating instances and can be a bit intense for newcomers. But there are a lot of options and custom offers that can be worked out. Also, our team is there to help you right from the start.

Many of our customers also choose to form integration networks with various connection models, such as hub and spoke or peer-to-peer, connecting with external teams or companies. A flexible network licensing model works well for such cases. We offer this as a part of our enterprise package.

The Bottom Line: Exalate’s pricing is competitive and fair & provides better value for money as compared to Getint. With the vision to form a worldwide network of connected companies, we see customers expanding their integration networks with a licensing model that ensures better value for money. 

Error Handling 

Getint provides an overview of the errors in their centralized UI without a dedicated section. It provides a summary of all the runs, triggers, outcomes, `and statuses of integrations. If an error occurs, there is an explanation for the error that might help with further investigation. You can resync after resolving the errors. 

Exalate has a dedicated UI tab for errors. They are categorized based on which side the error occurs: incoming or outgoing. If a particular script line (s) throws an error, you get detailed error logs pointing to the specific line (s). 

You can always choose to debug the script to understand where things are going wrong. 

You can view the actual contents passed behind the scenes using the “Entity sync status” tab and use it to troubleshoot. 

The Bottom Line: We didn’t find any special difference between the way error handling happens in Exalate and Getint. 

Reporting and Statistics

Getint has a comprehensive interface for reporting and statistics, which is very handy. 

Exalate does not provide in-depth reporting and statistics just yet. We have the detailed logging and test run feature currently under development. You can track the progress here. 

The Bottom Line: Getint has better reporting capabilities than Exalate.

AI-Assisted Integration

AI is all the rage these days! 

Exalate’s AI Assist in Script mode is a deliberate attempt to make integrations useful and accessible to everyone, irrespective of their technical background. 

To use AI-powered integration in Script mode, you simply enter your requirements in the AI chat window, review the scripts the AI suggests, and publish them. Keep refining your prompt until you are satisfied with the result. 

As of the date of publishing this blog post, Getint doesn’t have an in-built AI capability for its integrations. 

The Bottom Line: Exalate’s AI Assist is a shift in the way traditional script-based integrations work. It is the first integration co-pilot that helps reduce the need to search for relevant scripts or write them from scratch. 

The Last Word

At the onset, though Getint and Exalate serve the same purpose, they are different in a lot of ways. 

Ultimately, the choice between Exalate and Getint depends on your specific integration requirements and priorities. If you seek a solid and powerful ongoing integration solution, with kickass support and AI-assisted integration, with a strong focus on data security and comprehensive functionality, Exalate is the recommended option. 

Key Takeaways

Side Note

During our research, we also came across Getint’s comparison with Exalate on their website. If you prefer getting to know their point of view, you can always read it here. 

But, why did we think of sharing it? Well, competition is healthy, and we know our users have choices. So, to stay in tune with the market and its trends we wanted to share all perspectives with you. 

The sole purpose is to give you all the information available to us without any assumptions and present the reality as it is!  

While doing so, we meticulously reviewed a wide range of Getint resources, including product documentation, customer feedback, case studies, and more. Our team dedicated ~14 hours to research, testing, and validation to ensure that every aspect of the comparison reflects our best understanding of their platform.

Recommended Reads:

• Integration Showdown: Unito App vs. Exalate – Which Tool is Right for You?
• Adaptavist ScriptRunner Connect vs. Exalate: How Do They Compare?
• Backbone Issue Sync vs. Exalate: An In-Depth Comparison
• ZigiOps vs. Exalate: A Side-by-Side Comparison
• TFS4JIRA vs. Exalate: How Do They Compare?
• The Best ConnectALL Alternatives For Business Integration
• The Best MuleSoft Alternatives for Business Process Integration