You need integrations for your customers. If you can't provide the integrations they need, you know they'll start looking at other solutions that do. You may have even built a handful of integrations, but things didn't go so well. Your customers now have integrations, but building them took months and kept your dev team busy enough that you postponed essential work on your core product.
You realize that you need to build integrations faster, or you'll be unable to keep up with your current customers, let alone the new ones you'll add monthly.
But throwing more bodies at the problem seems like it won't help. So, what will?
An embedded iPaaS. It will allow you to build faster by:
- Enabling both devs and non-devs
- Leveraging a purpose-built infrastructure
- Taking advantage of reusable code
- Building once and deploying many times
- Empowering customers to build one-off integrations
Enabling both devs and non-devs
Traditionally, the task of building integrations rests almost entirely on engineering. After all, integrations are software, so we need devs to build them. But this reliance on devs for integrations often creates a bottleneck.
And, because integrations are often considered less important than other SaaS product features, they are frequently given a lower build priority and end up in an engineering backlog.
In either case, putting everything into the engineering basket significantly slows the integration build process.
An embedded iPaaS, on the other hand, allows you to use both devs and non-devs to build integrations.
While devs are still essential for writing code, non-devs can use a low-code integration designer to assemble integrations from pre-built and custom connectors.
Devs can also use the low-code designer or take advantage of the ultimate flexibility to write entire integrations in code in their favorite IDE using the code-native experience.
Whether you take a low-code, code-native, or combined approach to building your integrations, an embedded iPaas gives you much more flexibility in who you use to get the work done.
Leveraging a purpose-built infrastructure
Building an integration isn't the hard part. That is, assembling the functionality to send data from app A to app B is simple.
But that's the tip of the iceberg. How about the infrastructure that's necessary to support that visible integration functionality?
Integration infrastructure should, among other things, include or support:
- Authentication
- Compute resources
- Webhooks
- Customer UX
- Testing
- Versioning
- Logging
- Monitoring and alerting
If you are creating a sustainable process for B2B SaaS integrations, you must implement solutions for all these. Otherwise, your integrations won't meet your customers' expectations or be supportable for the long haul.
[The integration] was literally just dying. We were spinning up more servers. We were constraining the rest of the platform because the integration wasn't built in a manner that would allow it to scale.
An embedded iPaaS includes all of this essential infrastructure. This platform provides everything you need to build, deploy, and manage integrations.
As a result, when you use an embedded iPaaS to build integrations, your team can build much faster because you are leveraging the pre-built infrastructure rather than spending 80% of your time re-creating it.
Read more about Frank Felice and how Prismatic helped him successfully scale his integrations.
Building once and deploying many times
A primary drawback of coding an integration for a particular customer is that it only works precisely right for that customer. At least, that's the case when you build integrations in the traditional way.
Throughout integration development, your team confirms with the customer that the auth is set up a certain way, that a specific list of data elements is imported from the source system, that certain data elements are combined or split out, etc.
And that's great if your goal is to make only one customer happy. But that won't make your process for building integrations faster.
We built quite a few individually, one at a time, integrating into various SaaS products and we realized that there has to be a more sophisticated way of doing this. Building integrations one at a time is not going to work in the fast moving, fast-paced, tech industry.
With an embedded iPaaS, you build the integration to cover all the requirements your customers have in common but then set up the customer-specific items as configurable.
Then, when each customer activates the integration, they'll work their way through a config wizard that allows them to customize the experience to suit their unique requirements.
Doing so substantially speeds up your integration build time. True, it may take a bit of work to lay out the common vs customer-specific functions of the integration, but spinning up the 2nd customer (or the 200th customer) on the same integration will be so much faster than trying to build and deploy a slightly different integration for each customer.
Read more about Alttaf Hussain and how Prismatic drove explosive growth for integrations.
Taking advantage of reusable code
Non-reusable code is often found in integrations built the traditional way. And it's part of the reason that creating integrations this way is slow. This non-optimal approach to coding integrations starts with an understanding that a customer's needs are unique and must be addressed by building something from scratch to address that exact need.
Customers will sometimes have unique needs (and we cover the best way to address most of those in the next section), but there is usually substantial overlap in customer needs, and customer-specific code isn't required when one can create customer-specific configurations.
Beyond such configurations, an embedded iPaaS allows you to create code in reusable chunks.
This includes the standard API connectors that come with the platform and other components that allow you to perform standard functions like branching, looping, data mapping, and more.
And there are also custom connectors. You can write a custom connector that allows your customers to easily access your app's API. You'll write this connector a single time, but you can use it to build whatever integrations your customers need with your app. You can also enable that connector so your customers can use it to create one-off integrations themselves.
Reusable code, whether pre-built with the embedded iPaaS or something you write, helps build future integrations much faster.
Empowering customers to build one-off integrations
Having your non-devs and devs work together to build integrations makes a lot of sense, as we've already covered. But there's a way to increase the integration build speed even more for a particular class of integrations.
If you look at the integrations a single customer needs, they'll often be the same integrations all your customers need. These are integrations between your app and industry heavy hitters (like Salesforce or Zoho for CRM). Or they could be integrations with niche apps for your market vertical. In either case, these are the integrations you'll prioritize for development because of the value they'll provide to your entire customer base.
However, your customers will also want another type of integration. This is the custom, bespoke, or one-off integration. Sometimes, it may make business sense for you to build these integrations for a customer. However, for most of these scenarios, you'll not want to direct your integration team to spend time on an integration that only provides value to a single customer.
Despite this, you'd like to make the customers happy by solving these unique integration needs. So, what do you do?
That's where an embedded iPaaS comes to the rescue. With an embedded iPaaS, you can provide your customers with an embedded workflow designer that allows them to build whatever one-off integrations they need. They can take advantage of pre-built and custom connectors and templates for common scenarios (such as integrating your app with an MSSQL database).
As a result, individual customers can create those unique integrations they need without waiting for however long it might take for them to become a priority for your team.
Once again, an embedded iPaaS allows you to build integrations faster, integrations that might otherwise not be built at all.
Faster is better with an embedded iPaaS
Sometimes, doing something faster leads to more mistakes. However, using an embedded iPaaS to build integrations faster is grounded in best practices. Using an embedded iPaaS to build integrations makes you much less likely to cut corners or overlook essential requirements.
If you need speed to satisfy your customers' integration requests, it's time to go with an embedded iPaaS. You'll be able to use your team more efficiently, ensure consistency from one integration to the next, and even allow your customers to address their one-off integration needs – all without derailing your product roadmap or adding more devs to your team.
If you'd like to see in detail how an embedded iPaaS can help you turn around new integrations in days instead of months, schedule a demo, and we'll be glad to show you how it works.
