Case Study

How Justuno builds multiple integrations per week using Pandium

After a bad experience with a traditional iPaaS tool, Justuno needed an integration infrastructure partner who would give them complete code ownership and a platform to support their rapid development needs.
Use Cases

Migrate existing integrations

Speed up integration development

The Challenge

For years, Justuno relied on in-house developers to build and maintain their integrations with technology partners. However, as their platform expanded and APIs evolved, this approach became increasingly unsustainable due to enormous developer debt. 

Seeking a solution, Justuno turned to a well-known traditional embedded iPaaS (Integration Platform as a Service) tool. They planned to outsource integration development entirely. Initially, things seemed promising. But after six months, 3rd-party development came to a standstill, leaving Justuno at the mercy of a stagnant platform and unable to make crucial updates or add new integrations.

The Solution

Faced with mounting frustration and the prospect of starting from scratch, Justuno turned to Pandium. They needed a platform that offered them complete ownership and control over their code, rapid development, and reliable support in rebuilding their integrations. 

The Pandium team built all the connectors that Justuno required for their existing integrations. In just 30 days, Justuno was able to rebuild integrations using Pandium’s Integration Hub and has 100+ tenants live on the platform.

Now that their initial migration is complete, Justuno is on track to create 1-2 new integrations per developer per week from now on.

The Results

integrations migrated
tenants live in the first 30 days
new integrations built per developer per week

The Full Story

DIY integrations were causing issues

Justuno is an on-site messaging platform that powers intelligent product recommendations, lead capture, conversion optimization, and message banners. They help companies increase website leads and conversion rates to generate more revenue.  

For years, they developed all of their native product integrations in-house. 

According to Travis Logan, Justuno’s CTO and Co-Founder, those early integrations “weren’t robust or fault-tolerant. They were quick, sloppy, get-them-out-the-door type situations.” But, over time, the Justuno platform evolved, and their integration needs evolved along with it.

They implemented processes and developed and launched more sophisticated integrations. But issues started to arise.

According to Travis, their integrations had “become a kind of Frankenstein monster, so we ran into enormous developer debt.”

“We had to maintain the existing integrations because of API depreciation and new API updates while also juggling the never-ending list of new integrations that our partnership team was requesting, our CS team was requesting on behalf of customers, or our self-service customers were requesting.”

Plus, the time it took Justuno to develop integrations was highly variable.

Timelines depended “very much on the integration partner's API. Of course, some companies used dinosaur technology — those would take quite a bit longer. What almost always took a long time was getting a hold of API credentials and a staging environment with the integration partner that you could test against.

Building DIY integrations was causing bottlenecks that negatively impacted Justuno’s customers, who were “chomping at the bit for certain integrations.”

Trying a traditional embedded iPaaS tool

Justuno decided they needed to outsource the massive workload of building and maintaining their integration ecosystem from their internal team. So, they began shopping for a traditional embedded iPaaS (integration platform as a service) solution.

“We reviewed a few companies in the space before we were aware of Pandium, and we moved forward with a well-known one of those platforms. There was a very nice honeymoon stage. They were doing all the development and maintenance for us. That took so much weight off our shoulders from an integration standpoint. But after the first six months, things didn’t go as planned,” said Travis.

Development came to a standstill

Six months into their contract with Justuno, the traditional iPaaS tool pivoted. Despite integration development services being a contractual obligation in their service agreement, the iPaaS tool slowed their development work so much that “we could basically say it stopped,” said Travis.

“All of a sudden, it was even more of a bottleneck than ever because we couldn't go into their system and develop our own integrations. We literally had to wait for them to create them, and instead of taking two to four weeks to build one, it took six months.

That was the largest pain point because that's what they sold us. That was the leading value proposition of that company and their service — the fact that we didn't need to put our own dev resources into it. It was a bait-and-switch type situation,” said Travis.

The situation quickly became untenable, and Justuno began the search for a new, more reliable integration infrastructure partner.

Evaluating other platforms

Justuno knew they had a long road ahead. They would have to rebuild all their integrations on whatever new platform they chose. So, they identified the most important criterion when shopping for a new integration platform.

Owning their code

They wanted to own their code so they would never be forced into a similar painful position again.

“We had 40+ apps developed on our old iPaaS system that we couldn't port over because it was technically their code, not ours, since it's all built into their system. We, as Justuno, had to basically start over,” said Travis.

Rapid development

Speed of development was also a significant factor for Justuno. According to Travis, “When we were looking at alternatives, quite a few companies in the space did similar things to the previous platform we used, but none of them offered development services. Or if they did, it was using a professional services route where you pay a substantial amount but maybe get one release a month, which is not fast enough for us. We're trying to get to 100+ releases, and we can't wait ten years to get there.”

Justuno needed a platform that could handle their rapid development needs. “Something that we could build with our own code on and then use the system’s vaulting service, logging components, staging, and production to really pick up the pace of development. And also keep things consistent. Something to help steer us on the same path from one integration to the next,” explained Travis. 

Pricing that made sense

Justuno wasn’t satisfied with the pricing model of their previous iPaaS solution. They wanted something that better fit their specific needs. However, they found that almost all other platforms on the market used a similar pricing model.

“That pricing model didn't make sense. They offered something we really didn't need. You're paying for a lot of no-code type development for integrations. Even though, at the end of the day, you're still coding. You're just coding inside their platform rather than your own raw files that you're running. 

So, you still need a developer to do anything within their platforms. Anything you develop on their platform will only work on their platform because you don’t own your own code. 

So, no matter what, the alternatives we looked at were too similar to the platform that stung us so badly. 

We wanted to ensure we wouldn't be in the exact situation again.”

Moving to Pandium

After evaluating several platforms, Justuno decided to partner with Pandium for their integration infrastructure.

Justuno liked that they would own all of their own code using Pandium. According to Travis, “A key component of Pandium for us was the fact that we own the integration code that we've developed. That was a huge plus coming from the situation I just came from. I never want to be in that spot or have that hardship again. 

Giving his engineering team complete control over their integration configurations was also crucial to Travis. He explained: 

“Maybe you want some of the no-code features the other platforms offer and are willing to relinquish control to get them. But you’ll be at their mercy as a result. If that’s worth it to you, fine. Then, the other platforms might be a fit. But for us, wanting full control and having competent developers added up to Pandium being a very solid fit for us. So it was a no-brainer moving forward.”

Plus, Pandium only charges customers a flat platform fee and for their number of active tenants. 

This means Justuno can accurately predict how much they will pay each month and is not charged for features they don’t use. As they grow on the platform, their costs remain reasonable, unlike with their previous iPaaS solution.

The first 30 days

To start things off, Justuno met with the Pandium team and reviewed the list of their different integration requirements. 

“30 days was the original timeline to get us fully up and running on Pandium, and you guys nailed everything we agreed to have done in that period. Things moved very fast on that front,” said Travis

Together, the teams identified which connectors Pandium already offered vs. new ones that needed to be developed.

Pandium built the 23 new connectors that Justuno needed at no additional cost. 

Pandium also developed Justunos' first full integration to give their engineers a baseline they could replicate for future integrations.

“You knocked that first integration out in two weeks, and then we were off to the races on our end. 

Now, a single developer knocks out an integration per week. And that's not just counting the code that runs on Pandium. It includes the other aspects that have to do with our platform,” explained Travis.

Pandium as a partner

Justuno has had a completely different experience with Pandium than they had with their previous iPaaS platform.

Travis feels that “The team over at Pandium is amazing!”

Justuno and Pandium have worked closely together to help Justuno achieve their integration goals. The teams meet weekly to review progress and identify any areas where Justuno needs support. 

Justuno also has a dedicated Slack channel with the Pandium team for any ad hoc questions or support requests.

In Travis’ opinion, “The communication between us is stellar.”

Justuno also feels that the alignment between the two company cultures has been a key to success, saying, “Pandium feels very similar to Justuno from the standpoint that they have a good revenue foundation and are a stable company, but still have a startup mentality and feel. And I mean that in a positive way.”

Travis went on to explain that:  

“Pandium is very nimble and listens to customers' needs and requests. We've said, “Hey, the platform could be better if it does this, or we really could use this feature,” and a week later, those things were in the staging environment. That's been amazing to have.”

Set up for future success

Now that they’re using Pandium, Justuno is set up to grow their integration ecosystem quickly.

After taking nearly a decade to build their first 50 integrations, now Justuno “can produce 1-2 integrations per week per developer moving forward,” explained Travis.

They recommend other software companies partner with Pandium to reach their integration goals, saying:

“I would absolutely recommend Pandium to other SaaS companies. It was a very distinct fit for us. The other alternatives were all in similar buckets, but Pandium was in a very different bucket that was a perfect fit.”
We tried DIY integrations and a traditional embedded iPaaS tool, but nothing worked long-term. That’s why I’m so glad we found Pandium. Now, I know we’re set up for success today and far into the future.
Erik Christiansen
CEO, Justuno

From the Blog

Check out our latest content on technology partnerships, integration and APIs. Access research, resources, and advice from industry experts.

The B2B SaaS Guide to Ecommerce Integration Platforms: How to Find the Right Fit

Ecommerce integration platforms make it easy to create native, user-facing integrations. This guide helps you find the right integration platform for your B2B SaaS app.

The Hidden Limitations of Low-Code and No-Code Embedded iPaaS Solutions

Explore the hidden drawbacks of low-code and no-code iPaaS solutions, including restricted flexibility and vendor lock-in risks.