Why SaaS Product Teams Struggle With Integration

If you've got a SaaS product, you have to consider integration. You have to decide to whom you'll integrate, how you'll get it done, how you'll take care of said integration, and how you'll monetize and/or finance it.

Integration is hard, and most SaaS product teams will struggle in some way with getting it done. In this article we'll dive into where exactly SaaS product team's struggle with integration and how you can minimize that struggle.

The following are some reasons SaaS product team's struggle with integration.

  • Not enough time or focus to get integrations done
  • Lack of engineering experience building effective integrations
  • A product that isn't ready for integration
  • Not understanding which integrations are most important to have

Let's dive into each one!

Insufficient Team Focus

One of the biggest reasons SaaS product teams struggle with integration is simply lack of time and bandwidth to build integrations. This is especially true of earlier stage SaaS companies, still trying to hit the growth curve on a shoestring budget.

This challenge shows up in product roadmap meetings. You've got a team of 8 developers, and they have x capacity to get work done. Inevitably, though, you've got a feature request backlog of 10x, so the heads of engineering and product and (usually) the CEO have to make some decisions.

What gets cut? What gets deferred? What gets done.

If you're not building an integration product, chances are a lot of integration requests get cut or deferred. It's not hard to see why those requests get cut for features that are directly related to your core product. You aren't an integration company!

The result is that many SaaS companies view "putting up an API" as sufficient to meeting their customers' integration needs.

While deploying an API is a best practice, stopping there means you obligate your customers to work with third party solution integrators (SIs) or integration platform-as-a-service (iPaaS) vendors to implement their requirements.

What To Do

You should be able to calculate the forecasted value of an integration, so you can anticipate the ROI on the development you put into it. This will help you reconcile its value in financial outcomes and not just "wants and needs".

For an early-stage SaaS company, growth is the number one goal. Work with the sales and business development teams to estimate how much potential revenue is pent up in the funnel that is partially or completely stuck because you lack integration to a certain system. Align that revenue potential with the time/cost that goes into the integration to that system. Don't forget to forecast ongoing maintenance costs.

Remember: SaaS revenue's recurring nature means the sooner you start collecting the subscription, the better. Unlocking revenue potential sooner by deploying integrations (or any feature for that matter) has compounding ROI.

Lack of Integration Experience

Many SaaS product teams do find the capacity to build integrations. Some even make it a strategic imperative. But, knowing you need to build integrations and actually doing so successfully are different issues.

Integration is a specialized engineering discipline. Knowing how to write code that talks to an API is not sufficient for building reliable, high-volume integrations. Integration at scale requires understanding of:

  • Modern DevOps technology and processes
  • Microservices, serverless, and horizontal scaling
  • Cloud computing
  • Monitoring systems and support/operations process
  • User experience

It helps if you or your team understands all of this specifically in the context of enabling people other than yourselves (your customers) to enable and use high volume API integrations.

There's nothing wrong with your team if you don't have this experience. Most engineers--even really, really good ones--haven't had to build a scalable integration product before. But, you can't will your way through it without paying a heavy cost.

Lack of experience will start show when you add many customers to an integration you've built. You may find yourself dealing with large amounts of faults or errors. You may start to experience crashes because of volume spikes. Your customers may be overwhelming the support team with requests for help.

What To Do

When you don't have appropriate experience on your team, the first and obvious answer is hire for it. Look for team members who can add value according to the above list. Bonus points if they've worked for an integration company before.

You can also send your team on a learning journey. This takes longer, but you'll build the skills into your existing team. DZone's integration content is particularly good, free content. You could also consider a Blended Edge integration bootcamp to rapidly get your team up to par.

Product Isn't Ready for Integration

Many SaaS product teams recognize the need for ecosystem integrations and they've allocated their budget, but their product isn't ready to be integrated.

Early stage software companies often design products around features represented by a user interface. This tends to create APIs that are built to support a user interface, not APIs that are designed to be an interface themselves.

Others deploy public APIs for external consumption, but mostly as a reaction to specific customer requests as they come.

Some software companies don't deploy APIs at all. (Eek.)

In any of these cases, your API will tend not to look like a fully thought-through, consistent developer interface. Couple this with lack of documentation, developer tools, and community support and you make integration to/from your product pretty hard (even for your team).

Here are some common signs your product isn't ready for integration:

  • Lack of consistent or correct application of a standard (REST, OData, GraphQL, etc.)
  • Missing basic functions for querying and CRUD
  • Old or simple authentication and authorization features
  • Inconsistent or unclear application of status codes and error messages
  • Any hints about the internal workings of your product exposed to the world through the API

What To Do

Unfortunately, the only thing you can do about your product not being ready for integration is to get it ready. And, "forget it" is not an answer that will lead you to success.

Before you start writing code, refactoring, or paying off technical debt, you should look at why your product ended up where it did and why it's not prepared for integration. Software simply the output of the systemic realities of a software team. There's a reason you are where you are.

You may need to adopt some fundamental culture or process changes like design thinking or domain driven design. You may need to reorient your architecture principles around "API first" ideals. You may want to seek expert help understanding how to improve your product team's ability to write integration-ready software.

And, in case it isn't totally clear, you do want to write integration-ready software.

Misunderstanding of Ecosystem

Ok, so you've got the time and you've got the skills. Your API is stellar. You still have to build the right integrations.

The funny thing about ROI is that you've got to get that return. Without a proper understanding of your ecosystem--the complex web of competitors, compatible products, etc.--you risk investing in integrations that don't actually unlock much revenue potential.

Sales prospects will say a lot of things, especially if they are explaining that they won't be purchasing your product. "Integration to X is really a deal breaker for us," is a common one. Make sure that the information you have about which integrations your customers want is accurate and vetted. Make sure you measure how much demand actually exists.

Building an integration that few use comes with real cost and opportunity cost. Sometimes it's just going to happen. Sometimes you'll do it intentionally to land a whale of a customer. But, you should try to avoid it as much as possible.

What To Do

Disciplined customer development, regular review with product and customer success teams, and customer commitment are the keys to avoiding investment in unwanted integrations.

No product team has perfect information, but teams who are dedicated to understanding their customer's needs and realities are less likely to make this mistake. Build a trusting relationship with your market. Network and learn from others in the ecosystem. Be friends with compatible solutions. Be friends with competitors. Be friends with companies that you'll never run into.

Then consider building integrations along with customer commitments. If you can pre-sell a new integration to a small number of trusted customers, it helps to validate the decision.

Integration is hard.

If you find that you are a SaaS product team struggling with integration, fear not. You are not alone.

Integration is a difficult, specialized engineering discipline, and it takes time to get really good at it. We argue that even those who are leading the market today are still not doing nearly good enough.

The most important thing is to recognize where you are failing and where you are succeeding so that you can improve the former and double down on the latter. Perfection is the enemy of progress. Just do better than you did yesterday.