‍Scaling Product Integrations: How Everyone On the Team Helps

build a plan for building integrations!

We've launched a new product called Integration Planner to help you make better decisions about what integrations to build and when to build them.
get started for free

For a SaaS product company, integration is a cross-functional responsibility.

It’s not the Partnerships team’s job. It’s not the Engineering team’s job. It’s not some third party’s job. (At least, it’s none of those teams’ jobs, solely.)

To scale an integration program that underlies a successful ecosystem-led strategy, you must think organization-wide. While some functional areas are more involved than others, everyone plays a part.

In this post, we’ll break down who does what, when it comes to scaling a successful integration program. We’ll also cover how these cross-functional goals and responsibilities as the program matures.

Three Phases of Scaling Integrations

We like to think of scaling an integration with a three-phase framework. You could consider them like “crawl, walk, run”, but that’s not to suggest that the first phases are slow or easy.

This section describes each phase and its objectives, so we can overlay them with specific jobs for the various functional areas within your team.

Start Up (The Wobbly Toddler Years)

During the “Start Up” phase, your company is just trying to get their legs under it when it comes to integration. These are the wobbly toddler years. 

You should generally expect to arrive at this phase pretty early in the life of the business. Yes, you need to build out your core product before you have anything to integrate to other products, but the earlier you think “ecosystem” the better.

As you do that, you’ll have to learn what that means for your business and your product. Every product team goes down a unique path, because every product is different.

During the “Start Up” phase, you mostly are experimenting and orienting yourself to the kinds of integration approaches you want to scale. Not every possibility is right for everyone, so you need to feel out what’s right for you.

How do you know you’re in this phase?

You can generally tell you’ve entered the “Start Up” phase by observing the following:

  • Quantifiable requests from customers for integrations are starting to come in
  • You start to recognize the boundaries of your product strategy
  • You also start to notice complementary solutions that might expand your product
  • Beginning of a partner program that includes technology partners
  • Unsolicited requests from potential technology partners
  • Requests from partners, customers, or other stakeholders for APIs or API features

Scale Up (The Awkward Adolescent Years)

During the “Scale Up” phase, your objectives are to deliver on what you’ve learned and established during the “Start Up” phase.

During the first phase, you should be performing small experiments and learning more than you should be executing. Now, it’s time to execute. It’s time to build repeatable motions within your teams and across functional areas to build an integration portfolio.

With an established ROI model for integrations and a cross-functional motion between Product and Partnerships, you can start to look at integrations in terms of a backlog to be delivered. Prioritize that backlog by effort (time/difficulty to deliver) and impact (mostly ROI), and work from the top down.

How you organize around delivering that integration backlog may vary. There should be a mix of internally and externally delivered, but everyone’s mix is different. 

For ones that you deliver, some teams will keep that responsibility within the core Product/Engineering teams, right next to the rest of the product backlog. Others will create dedicated integration teams that operate in parallel with the team delivering core product functionality.

How to scale up your integration program is a huge topic for many more blog posts. The bottom line is that in this phase, you build the muscle to deliver your integration backlog, delivered directly by your internal teams and with integration partners.

We call this phase the “awkward adolescent” years, because while delivering integrations is largely a common Product team problem, it looks very different from delivering core features. The dependency on a tech partner, their product roadmap, and their APIs fundamentally changes how an integration (as a feature) is to be delivered.

There will be growing pains. It takes time and experience to get good at absorbing this added complexity.

How do you know you’re in this phase?

You can generally tell you’ve entered the “Scale Up” phase by observing the following:

  • You have a long list of integrations to deliver and at least a general idea of the order in which they should be delivered
  • You have a mostly decided on approach (or approaches) to delivering various categories of integrations
  • Your tech partnership program collaborates with Product on then backlog, specifically where integration delivery is concerned
  • You are able to deliver more than a dozen or so integrations (think roughly 5x to 10x the number of integrations you delivered in the “Start Up” phase)
  • Executives of the company begin to talk about integrations as revenue generative, not just a cost of business
  • APIs are viewed as a key component of your product by all stakeholders, including your customers

Scale Out (The Working Professional Years)

Eventually, you’ll find that the market’s demand for integrations to your product exceeds your team’s capacity to deliver them all (at least profitably). This probably means that you’ve reached the “Scale Out” phase and that it’s time to open up your integration portfolio to external contributors.

During the “Scale Out” phase, you take all of the processes that you’ve scaled up in the last phase, then you turn them into a program that enables technology partners to build integrations inside your platform.

Put another way, you transition from “you building to them” to “them building to you” without relying on “them” to provide the requisite integration infrastructure.

This is a phase that you only see at large ecosystem players (Shopify, Hubspot, Salesforce, etc.) today, but there’s no necessity to be huge to deliver on this vision. The biggest limiting factors today are the lack of maturity in most integration programs and the fact that (until now) there aren’t off the shelf technology platforms to support such a program. In addition to building an ecosystem hub position, you have to build out all the tech to support the program.

The “Scale Out” phase is where you can start really delivering tech partner value. Ideally you create a virtuous cycle of adding tech partner value which adds customer value and vice versa. You become an ecosystem facilitator more than a builder.

How do you know you’re in this phase?

You can generally tell you’ve entered the “Scale Out” phase by observing the following:

  • Simply having an API available–even a strong one–for tech partners isn’t efficient enough in scaling up the program
  • You’d internally delivered on all of the highest value, strategic integrations and you don’t want to scale it further (think one or two dozen as a rule of thumb)
  • Your tech partnership program is scaling, formalizing, and potentially even being monetized
  • You have a significant inflow of new integrations requested by customers, especially ones for potential partners you never had on your radar
  • There are other companies making money building on, to, or around your product (e.g. SIs, agencies, or VARs who offer complementary solutions)

Goals and Responsibilities at Each Phase

Now that we’ve gone through the three phases of scaling an integration program, it’s time to look at the company’s overall goals and each functional area’s responsibilities at all of the phases. This section covers exactly that.

Start Up Phase Goals & Responsibilities

Your goals for moving through the “Start Up” phase should be the following:

  • Perform low-to-moderate risk experiments to understand how various integration approaches (build in-house, iPaaS, etc.) work for your team
  • Identify the key categories of integrations that are important for product growth
  • Establish a “buy, build, or outsource” plan for those categories
  • Develop an ROI model for integrations
  • Establish a collaborative motion between the Product and Partnership teams

The different functional areas of your company have the following responsibilities during the “Start Up” phase:

Partnerships

  • Learn about and map out relevant ecosystems
  • Begin representing your company in those ecosystems
  • Educate the rest of the company about the ecosystem dynamics and opportunities

Product

  • Explore cross-product use cases that add value beyond your product
  • Learn the basic engineering concepts that are applied to build integrations
  • Build a strong core product that represents well within the ecosystem

Engineering

  • Experiment with methods for delivering integrations and decide on what approach(es) to use for the long term
  • Build APIs and a developer relationship motion to prepare for future scale
  • Learn best practices for APIs and integration engineering; begin to apply them 

Sales/Marketing

  • Catalog the integration requests from leads and prospects as soon as possible
  • Work closely with Product and Partnerships to understand how to sell the initial integrations
  • Learn the process of prioritizing and delivering integrations

Customer Success

  • Contribute monitoring and support requirements for integrations to engineering
  • Learn the basics of the most important systems to which integrations are built
  • Work with Product to have a clear understanding of an integrations functionality

Scale Up Phase Goals & Responsibilities

Your goals for moving through the “Scale Up” phase should be the following:

  • Establish integration as a key part of your product and go-to-market strategies
  • Demonstrate successful business cases for integrations (hint: some are going to be failures…that’s okay!)
  • Learn where scaling internal delivery of integrations will start to have mitigating returns
  • Establish mature API update and developer relations processes 
  • Establish and operationalize analytics about your integration portfolio
  • Deliver integration enablement features within your product, like an integration marketplace experience and in-context integration setup

The different functional areas of your company have the following responsibilities during the “Scale Up” phase:

Partnerships

  • Operationalize processes for the entire tech partner journey
  • Act as an extension of the Product team to inform of possible integration improvements
  • Accelerate ecosystem presence by sourcing additional integration opportunities

Product

  • Expand Product motion or create new motion for reliable, repeatable integration delivery
  • Provide end-user enablement features, like an integration marketplace
  • Begin to build a co-innovation program with close partners to collaboratively build integrated cross-product experiences

Engineering

  • Fully adopt and begin to scale the chosen integration technology approach(es)
  • Full commitment to API development and delivery
  • Help Product and Partnerships size and prioritize integrations

Sales/Marketing

  • Develop and publish case studies to represent successful integrations
  • Include integration and cross-product functionality in core market message
  • Establish a collaborative cross-company sales motion with tech partners

Customer Success

  • Establish a cross-company support model with tech partners
  • Incorporate a tier 2 support relationship with the integration tech vendor (if applicable)
  • Document integration functionality to scale supportability within the team

Scale Out Phase Goals & Responsibilities

Your goals for operating in the “Scale Out” phase should be the following:

  • Create a flywheel: more partners to add move value to customers and vice versa
  • Implement processes to orchestrate and automate new integrations instead of building all of them
  • Establish tech partner enablement processes for onboarding those partners and helping them to build their integrations
  • Structure ecosystem and integration strategies into the company’s financial model

The different functional areas of your company have the following responsibilities during the “Scale Out” phase:

Partnerships

  • Transition from partnership recruiting and onboarding to partner enablement
  • Build automated systems for interacting with partners and making them successful
  • Manage an ecosystem P&L for ecosystem-sourced and -influenced revenue

Product

  • A significant part of the product is now ecosystem-focused–consider a dedicated team
  • Collaborate with strategically important tech partners to build deep product integrations
  • Think ecosystem-first when executing on all of the product roadmap

Engineering

  • Focus on scale and quality for APIs and integrations
  • Implement best practices and processes for integrations reviews and approvals
  • Produce additional tooling, libraries, and utilities to assist with tech partner integration

Sales/Marketing

  • Implement a mature co-selling motion with tech partners, big and small
  • Shift integration ecosystem to a primary selling feature
  • Collaborate with Partnerships to build out an ecosystem-sourced revenue engine

Customer Success

  • Expand support processes to ecosystem and tech partners
  • Create centers of excellence around different categories of integrations
  • Implement processes that allow you to scale reach without excessively scaling expense

Integration is Everyone’s Job

While in most cases one functional area has final ownership over building and managing product integrations, the entire company must be involved to make it a success.

The best things you can do today, no matter what your functional area, are to make an effort to understand which phase your company is in and to start delivering on your area’s responsibilities accordingly.

start building better integrations.
The best way to see how Doohickey helps you build better integrations is to try it out.
get started for free