API Adoption: The Dangerous Delay

Launching an API is the easiest thing you’ll ever do.

On the minimum end, you can put a framework in front of your database and call it done. If you add annotations to your source code, you can even auto-generate documentation. If you want to get fancy, you can use OpenAPI to auto-generate SDKs and a developer portal. BOOM. Done. You have an API.

But then you get to the real problem: API Adoption

Over the last 15 years of working with APIs, I’ve seen hundreds of companies launch APIs “successfully” and never actually get people to use them. Even when their teams go above and beyond with docs, SDKs, samples, etc, still no one cares. I know. I’ve done that once myself. It hurt. It hurt to spend weeks and months building something to only hear crickets.

In the ideal world, our users/customers find our API, integrate it, and launch to getting massive month over month growth. Unfortunately, we live the real world and API usage really follows a counter-intuitive pattern which maps into three steps usually called: Exploration, Integration, and Adoption.

Let’s talk about what that looks like.

Exploration

When someone first learns of our API, whether it addresses a major problem or just a curiosity, they play with it. They read about it, check out the How To or Quickstart guide, and try some code. Overall their usage looks like this:

At this stage, the developer is just exploring. They may not have a project in mind or an immediate need but they’re figuring out if our API does what they expect. The good news is that now they know about us. The bad news is there are 50 other more important things on their Jira board, the dog is barking, the newest Netflix series just dropped, and the kids need dinner.

And then time passes..

Integration

At some point in the future, a requirement appears. Even better, that requirement needs our API! Even more better, that requirement is top priority in this sprint. Our API has another chance to shine!

Unfortunately, we don’t have the SDK for this week’s Javascript framework and now we feel the pain of our mediocre documentation but the docs are accurate and we gave useful examples, so the developer can still integrate the API. This is a huge win and we watch traffic go up for a few days or even a week.

And just as quickly, the traffic drops all the way down to zero. What happened!?

Adoption

Whew. It turns out the drop off we saw was simply the developer finishing the sprint. Now that it’s tested and deployed, we’re into production.

And NOW we see the hockey stick we hoped for. Now they spend money with us. Now we see more and deeper integrations.

But is this what API Adoption really looks like?

Unfortunately, yes.

Over the past ten years, I’ve validated this with API companies of all shapes and sizes. Some you’ve heard of and probably use, some didn’t manage to turn themselves into real businesses. Regardless, every single one saw an adoption curve like this.

Except when they don’t and that creates the Dangerous Delay. It is the single most dangerous moment for an API company.

The Dangerous Delay

The Dangerous Delay is the time period between these two bumps. At first glance, it’s the time between when a developer finds your API and integrates your API. In more precise terms, the Dangerous Delay is the time it takes for your API to change from a curiosity to a need.

When I initially noticed this trend working with one API company’s data, their specific delay was an average of nine months. Nine months. For every prospect who found the API in January, they wouldn’t integrate until October. That means as you experiment with marketing and sales, you can’t even guess which dollars were useful or useless until multiple quarters later.

The good news is adoption means we may have a business. Every dollar keeps us in the fight a little longer to let us experiment, iterate, learn, and apply the results. Unfortunately, we need to figure out how to pay the bills in the meantime but we attempt a variety of things to shorten this delay. In the situation above, with a lot of work, we were able to reduce nine months to five months. It’s still a long time but more manageable.

The bad news is this is scary. In our nine month example, month one and month eight are identical with zero usage. In fact, we don’t know “nine months on average” until we pass nine months and have adoption data to look back on. That could easily take twelve or fifteen months.

This is the danger of the Dangerous Delay:

We can’t tell the difference between “not adopted yet” and “never going to adopt” until well after the fact.