The History of IPaaS

Current integration platforms are costly, complex, and lack customisation, but AI-powered iPaaS (Integration Platform as a Service) promises to streamline the process with universal API compatibility, automated configuration, and enhanced user customisation, addressing long-standing issues in the integration landscape.

Integrations are painful. Expensive to build, annoying to maintain, & they never quite do what everyone wants. IPaaS has not evolved much since it first came to market & still leaves users with tens of thousands in implementation fees per integration, indicating how little they solve the core problem. With AI now an increasingly mainstream tool employed by many code platforms, where does the future of integration lie?

A brief history of the IPaaS market to date:

Pre-IPaaS: Code everything, which sucked! Building every connector to handle the authentication, server access, & endpoints was hugely time intensive. Then came wiring up the integration’s transformation logic. Most integrations employ hundreds of data fields, making development a 6+ week drag. This is without mentioning maintenance, which becomes a full time task as soon as you’re supporting more than 10 integrations

Multiply this by the hundreds of integrations you need to offer as a software product, and companies were spending millions on internal engineering teams to tackle this challenge.

Multiply this by the hundreds of integrations you need to offer as a software product, and companies were spending millions on internal engineering teams to tackle this challenge.

Generation 1: IPaaS

What is it?: Low code integration platforms hosting a library of prebuilt connectors into mainstream software.

What integration pain point did they solve?:

Endpoint connector development

Authentication into APIs

API updates / connector maintenance

What frustrations remained?:

Users still needed to develop the integration logic between APIs, which meant understanding each API

Deploying the integration still required hours of manual setup & testing

Generation 1.5: Simplified Integration Logic

What is it?: Low code integration platforms with prebuilt integration logic built into their tooling environment

What pain point did they solve?:

Simplified the logic of common workflows into prebuilt nodes so APIs’ core functions did not need to be individually configured

Enabled non-engineers to use IPaaS

What remained frustrating about using them?:

Deploying to users was still engineering intense

Generation 2: Embedded IPaaS

What is it?: IPaaS designed to simplify deployment by embedding straight into your software.

What integration pain point did they solve?:

End user deployment was custom end user to end user: Embedded IPaaS deployed their software into a user’s front end, making end user setup much easier.

End users could either one click setup pre-built integrations or configure their own.

What remained frustrating about using them?:

As more companies used more software, building out hundreds of integrations was extremely challenging.

While users could configure the integrations, customization was limited without full engineering support

Generation 2.5: Unified APIs

What is it?: A single API with integrations for relevant workflows built into multiple other APIs

What pain point did they solve?:

By integrating a users API into a single API, which itself was connected via hundreds of prebuilt workflows to other APIs, deploying multiple integrations was quick.

What remained frustrating about using them?:

By prebuilding workflows, its hugely limits the level of customization possible for both the user & end user. Unified APIs only work when the workflow provided is as needed.

Ultimately, however, none of these generations tackled the problems plaguing integrations resulting in trade-offs for users (& by extension, the end users of such integrations). Users of embedded IPaaS often complain of long lead times, high costs, & unpredictability on delivery timelines. In short, procuring integration is a black box. This is challenging as their end users demand an increasing number of complex & custom integrations.

“The 80:20 rule in integration is flipped. It’s not that 20% of users want 80% of an integration customized (effectively fully custom)... 80% of users want 20% of a standard integration customized, beyond that of configurable fields normally offered. This is much, much more work.”

In short, companies are procuring expensive integrations with no line of sight to completion or deadlines that ultimately can’t meet the scale or customization needs of end users. Generative AI offers potential relief to the challenge of integrations because of the customization & speed capabilities it can unlock.

Generation 3: AI enabled IPaaS

Platforms will begin to leverage AI to perform 6 key functions:

  • API agnostic platforms: Work with any API rather than just the prebuilt connectors available.
  • Accelerated integration planning: LLMs can pass through API docs relative to requirements much faster than humans.
  • Automated integration logic configuration: Platforms will leverage AI to configure the transformation tooling.
  • Shortened Testing: testing integrations is still highly human. How AI could impact this is to be understood but a number of AI-enabled code testing environments are now readily available in the market.
  • AI-enabled monitoring & maintenance: AI enabled integration development & testing will enable automated maintenance.
  • Highly customizable end user configuration: End users will be able to much more easily configure integrations to ensure it works exactly to their needs.

Start building today

Ready to start integrating?

Google Ads
Batch
Dropbox
Airtable
Asana
Calendly
Filter