Shipping Product Integrations

As a product manager, one way to unlock more functionality in your product and attract new users is to ship a product integration that connects your product with another product.

Consider this integration example: Google Calendar has an integrated workflow with Zoom, where you can instantly set up a Zoom video meeting through Google Calendar.

Google Calendar benefits from the Zoom integration because it easily enables its users to set up video calls within a seamless workflow. Zoom benefits from the Google Calendar integration because its users can spin up video meetings much more quickly.

Integrations are beneficial to both products. Why is that?

Both products gain new capabilities and new users by integrating with one another.

In other words, integrations bring the best of both products to end users, and provide them with new superpowers that they didn’t have before.

While integrations are incredibly powerful for unlocking new functionality within your products, they require you to work with others outside of your company.

That coordination challenge can be an incredibly difficult task to overcome. No matter what, you have to work with a third party to ship an integration, and working with third parties can be challenging.

For example, let’s say that you’re a product manager for Salesforce. You might work with one of the three kinds of integrations below.

• Customers: for example, a Salesforce integration with its customer OpenTable to enable community management

• Third-party developers: for example, enabling the developer Bluewolf to build on top of Salesforce for Bluewolf’s customers

• Third-party product partners: for example, a Salesforce integration with DocuSign to enable sending, signing, and tracking agreements and approvals in one central place

I’ve had the opportunity to work through dozens of integrations initiatives, for all three of the integration types above. While each one requires a different skill set and a different approach, they all share the same basic concepts.

Based on these experiences, I’d like to share some best practices on ensuring that you and your integration partners successfully ship your integration on time with as little heartburn as possible, regardless of what kind of integration it is.

Below, I’ll talk through how to craft a compelling integrations charter, how to kick off the project together, how to plan for the integration, and how to execute as a team.

You might be surprised to see that all of the items I mentioned are based on soft skills. You might ask, “Aren’t integrations mostly technical? Shouldn’t I be more worried about the technical challenges?”

In my experiences, I’ve found that the hardest technical challenges come from a lack of coordination and alignment. You cannot address coordination and alignment through technical skills; you can only address those through soft skills.

Plus, your engineering team should have the capability to take the lead on technical challenges. As a product manager, your focus needs to be on driving alignment and coordination, rather than on the technical nuances of a specific implementation.

If you want to be a successful integrator as a product manager, you’ll need to focus on the soft skills, because integrations rely on deep partnership with your implementation partner. So let’s get started!

Crafting the Charter

The single biggest factor for integrations success is an aligned charter. And, the single biggest factor for integrations failure is a misaligned charter.

Before you even begin working on the project timeline, first begin with the objectives of the integration. What is the intended user-facing objective?

I’ve seen too many integrations fail because one (or both) parties didn’t clearly understand the purpose of the integration from the user’s perspective.

If the end user doesn’t get any benefit from the integration, then there’s no point building the integration. It doesn’t matter if you believe that you’ll gain market share or you’ll gain more revenue. If the user has nothing to gain from it, then you’re wasting everyone’s time.

After all, the basic premise of product management is that you must first create value for the user before you can capture value for your business.

What new superpowers will you unlock by integrating these two products together? If there’s nothing new, then don’t do it.

For example, Google Docs has a huge user base, and Apple iMessages has a huge user base. Consider this thought exercise: should the two of them build an integration where iMessages automatically compile into a Google Doc?

At a surface level, you might be tempted to conclude that they should. After all, Google has a massive user base and many of these users leverage Apple products. The reverse is true as well - Apple has a massive user base, and many of their users benefit from Google products.

But, let’s look at the use case: compiling text messages into a document.

Is that valuable to the end user? Not really. The end user has no need for such a capability.

So, while both Google and Apple are huge companies, this particular integration makes no sense because it unlocks no value.

We now know that product integrations need to create value for end users, and not just for either of the integrating products.

Let’s say that you and your partner have identified what benefit the end user is going to get. It’s time to talk incentives: are both of you correctly incentivized to ship this integration?

I regularly see integrations fail because one party stands to gain disproportionate value from the integration, and the other party isn’t set up to benefit much at all.

The party that won’t gain as much will necessarily deprioritize the initiative. After all, they have other crucial initiatives that they need to focus on - initiatives that will give them more benefits than the integration.

And when one party keeps deprioritizing the initiative, the integration is doomed to fail.

What’s the value proposition for your company to take on this integration? And what value proposition is your partner getting for this integration?

It has to make sense for both of you, or else you won’t jointly prioritize the work and ensure that the integration happens.

One way to help level the playing field is to set up a revenue-sharing clause in the partnership contract. That way, the party who “wins” the most will share some of those winnings with the other party, so that both sides are ready to act as a single team.

Kick Off

Okay, so you’re both going to create massive value for the end user, and you’ll both stand to gain from completing the integration. Now, it’s time to get down to the actual mechanisms of the integration work!

Set up a kickoff meeting between you and your partner, and include engineering leaders from both sides. You want as much information to flow between all parties as possible.

Make sure you answer these key questions in the kickoff:

• What is the value of this integration to the end user?

• What is the value of this integration to both companies?

• What functionality is necessary to drive this value for the end users and for both companies?

• Which system is in charge of what functionality?

• Which team is responsible for what work?

• Who gets to make which kinds of decisions?

• What timeline are we working with?

• What’s the process for escalating, if either party is not meeting expectations?

The more alignment you can get upfront, the easier the work is going to be later. Trust me, I’ve been burned by these questions repeatedly, and having an upfront kick off means fewer confrontations, less friction, and faster delivery.

Be explicit with these decisions, record them somewhere, and distribute your records immediately after the kickoff.

Upfront Planning

Great, so now you have a compelling integration charter in place, and you know who’s responsible for what.

Is it time to roll up our sleeves and dive in yet? No, not yet. We need to plan ahead.

With integrations, I’ve found that the devil really is in the details. A minor missed detail upfront can literally cost months of development effort to fix.

Here’s a real life example: I was building an integration alongside one of my customers, so that I could integrate my product into their internal systems.

For more than two months, we had issues where neither of us could successfully call each other’s APIs, and we were both mystified. No matter how many emails we sent back and forth, we couldn’t get to a conclusive answer.

We were both absolutely sure that our respective APIs were being called with the right set of parameters and with the right logic.

That is… until one particularly astute engineer noticed that our product had case-sensitive parameters, whereas our customer’s system was case-insensitive.

In other words, something like “userName” had to be spelled exactly that way for our system to work, whereas our customer might try to call our functions with “UserName” or “username” and those calls would fail.

It took so long for us to find the problem, and all of that could have been avoided if we had spent time planning upfront and digging into the details!

So please, spend disproportionate time upfront on the technical details. Even if you’re not a technical product manager yourself, lean on your engineering team to surface as many assumptions and questions as possible.

Here’s what I’ve found to be useful.

First, have your team draw out the proposed architecture diagram and the sequence of network calls. This is just a fancy way of saying “which module is talking to which module, and when?” Having it in diagram form will make the world much easier to navigate.

Then, walk through the diagram with your integration partner.

You’ll frequently find that some modules need to be combined together, and others need to be separated out. Or, you’ll find that some of the calls are sequenced in the wrong way. It’s so crucial to ensure that you’ve got the right foundation in place!

Note that I’ve made the assumption that both teams have already agreed to the scope and the user stories that they’ll jointly be tackling, as part of the charter.

If you haven’t done that yet, then do that first. After all, your architecture must be based on the scope (and the shape) of the functionality that you’re providing to your joint end users.

Once you know which system is talking to which system, then it’s time to get into the weeds.

You don’t want to write a single line of code until you’ve gotten all of these questions answered:

• For each call, what does the request schema look like? What does the response schema look like?

• What are the parameters, and which ones are optional vs. required? What is the data type of each parameter (e.g. array, object, string, int)? Are there enumerations or is it free text? Is it valid for multiples of the same parameter to be sent or received?

• What is the naming convention for functions and data elements? Which systems are case-sensitive? Will you be using camel case or sentence case?

• What does the data structure look like within the databases on either side?

• Are the calls synchronous or asynchronous? What is the retry behavior, if any? What is the logging behavior, if any?

• Which environments will each party be using? Does everyone have all of the credentials they need to talk to each environment?

• Who’s in charge of error monitoring and logging?

• Who’s in charge of production support once the integration goes live?

The general principle: during the planning phase, get into the details and document your decisions for posterity.

That way, if your integration succeeds (and hopefully it will!), you and your partner can build even more integrations together, and your past work will already be cleanly documented for both of you to work off of.

Team Execution

You’ve fleshed out every detail. Now it’s time to ship as a single unified team.

I’ve found that when my integration partner and I treat one another as true teammates, that’s when we ship the highest-quality code at the fastest velocity.

I’ve also found that if my team doesn’t trust my partner’s team, then the entire initiative will quickly fall apart. While it’s important that we hold one another accountable, we also have to trust that each team will get their work done to the best of their ability.

While many product managers are great at leading their own teams, they may struggle to work with external teams. The good thing is that with a bit of mindset tweaking, it’s entirely possible to become effective at leading external teams too.

First, you and your integration partner must commit to tracking your progress together. Give one another full transparency and visibility into your backlogs, velocities, sprint plans, and resource allocations.

By doing so, it’s much easier for you to plan around one another’s constraints. Be proactive and share when you’ll get blocked, and proactively discuss how you can help unblock another other.

One of the most helpful actions either side can take is to provide mock responses for one another. A mock response is simply a “fake” set of data that one party provides to the other, so that the other party can implement without needing to wait for the actual API to be built.

For example, say that I’m on the hook to build a data verification function, and my implementation partner is going to send me a bunch of data to verify. But, let’s say that I haven’t built my verification function yet.

That’s okay. I can let them know that I’ll prepare a set of mock responses, based on a predetermined set of requests that they send me.

For example, if they send me Data Set XYZ, I’ll always respond back with a successful response. And, if they send me Data Set ABC, then I’ll send them back a response letting them know that the data cannot be verified.

While I haven’t written my function yet, they can now move forward without needing to rely on me. They can figure out how to continue building the happy path (where the response is successful) as well as how to deal with graceful degradation (where the response is a failure). They are no longer blocked by my team’s implementation of the actual full-blown functionality.

Of course, a mock response eventually needs to be replaced with the real function, but that’s a cheap and fast way to keep one another moving quickly.

And, while we’re on the topic of execution, remember that you still have to test. Allocate sufficient time in your project plan to jointly run through QA, including performance tests, unit tests, integrations tests, and user acceptance testing.

The second point to keep in mind is that you’re growing and leading both of your teams together. You’re not just executing and tracking velocity; you’re looking to strengthen one another.

So, commit to performing the full set of sprint rituals together too. Groom your sprints together, prioritize your sprints together, kick off your sprints together, have daily standups together, test your tickets together, and hold retrospectives together.

The more you both commit to acting as a single team, the more your teammates will actually act as a single team. That means fewer silos, more trust, more alignment, higher velocity, and better quality.

That leads me to my third point. You’re not just responsible for the operational mechanisms of both teams. You’re also responsible for the joint culture that you’re building together, and that means taking care of real human beings.

Celebrate together! When your joint teams reach particular milestones, go out for a meal or send a small gift to everyone on both teams.

Remember that integrations can sometimes feel like a slog. I’ve had integration initiatives run for more than 10 months, and that’s a long time to be working with an external party on a day-to-day basis.

That’s why it’s so crucial to keep everyone’s spirits high, and to ensure that you’re all working together as a real team.

At the end of your integrations journey, you will not only have an amazing integrated product, but also have made lifelong friends across companies. Savor the struggle, because that’s what will enable you to genuinely bond with one another.

Final Thoughts

Integrations are powerful for product teams because they enable you to specialize and focus on your product’s core capabilities, while relying on others to further extend your product functionality and your audience.

But, they’re also quite difficult to realize.

Integrations require deep levels of coordination and trust, and you need to be well-organized to bring your integration to the finish line.

By ensuring that you have a clear game plan for driving clarity, alignment, and coordination, you’ll dramatically increase the chances for success for both you and your integration partner.

And, by fully leveraging your soft skills, you can make even the toughest, most nuanced technical integrations much easier to bring to life!