We’ve all been there: you’re sorting through your smartphone and find an app that you don’t even remember downloading. You open it up, and, sure enough, you never finished creating an account. With a couple of taps, you banish the app in question from your phone forever.

You might not know it but, if you’re an API developer, the same thing is probably happening to your product right now; some people are signing up to your API and either never using it or letting weeks, perhaps months, pass before they actually try it out.

We can refer to the time between the signup process and making an initial API call as Time To First Call, or TTFC. In this post, we’ll be looking at why TTFC is such an important metric to track. We’ll also see if there’s anything you can do to improve it. (Spoiler alert: there is.)

A Deeper Dive Into TTFC

Above we suggested that Time To First Call refers to the time between signing up and making a call. In reality, tracking this metric isn’t quite that simple. Is measuring the time until a GET request is sent sufficient, for example, or should we be looking for a more complex query?

It also doesn’t seem right to include error messages, as any advantages of having a low TTFC are far outweighed by API consumers encountering errors on their first attempt(s) to call. And does the clock start ticking when someone signs up for an account, or would arriving at the documentation page of the developer portal be a better starting point?

We don’t have hard and fast answers to these questions, but the following seems like a reasonable template for measuring Time To First Call to us:

Time to First Call (TTFC): The time taken between a developer accessing documentation, and/or signing up for an API key and making their first successful API call (of any complexity).

The good thing about this metric is that, indirectly or otherwise, it’s probably one you already measure to some extent or another. Armed with the information above, you can ensure that you’re doing so consistently across all your offerings.

From Time To First Call to Active User

So what is a healthy target TTFC? Unfortunately, there isn’t a standard benchmark to shoot for because TTFCs can vary considerably. Measuring TTFC can depend on the complexity of the offering, the price (if any) of the service, whether or not the API or its developers are a known quantity, and how many competing products are on the market.

In the past, Twilio has referenced their efforts to enable API developers using their services to “get up and running in 5 minutes or less.” In their comparison reviews, Ably uses the following benchmarks for the comparable metric of ‘Time to “hello world”‘:

• 5/5 – < 30 mins
• 4/5 – 30 mins to an hour
• 3/5 – 1-2 hours
• 2/5 – 2-4 hours
• 1/5 – 4+ hours

You probably already have a rough idea in your head of how long a typical customer takes to place their first call. And it’s always interesting to see how that number lines up with reality.

Bear in mind that making a first call is very different from someone becoming an active user. Reducing the former won’t necessarily increase the latter, BUT it will likely increase your funnel’s number of potential users. Or, at the very least, an optimized TTFC will speed up the rate at which they make their way into it.

Exploring “First Call Motivators”

There are all sorts of reasons why someone might sign up to use your API and make their first call. In an article for TechCrunch, Joyce Lin covers a few of these:

• Actively searching for a solution to a particular problem
• Heard about your product and are curious about it
• A project or role requires that they use your service

Their enthusiasm, willingness to forgive flaws, and motivation to make things work will vary massively depending on which of those camps people who find your API fall into.

Depending on their first impressions, your API might become something developers can hardly resist trying on their lunch break. Or, it could be something that ends up at the very bottom of their to-do list. Regardless of how they find you, the secret sauce is to do the following as quickly as possible:

Demonstrate what your product does, how it does it, and why it’s the best at doing it.

Of course, all that’s easier said than done…

Improving Your Time To First Call

Reducing your average TTFC isn’t like, say, improving the load time of a web page. There’s no silver bullet for improving the metric, but there are different things you can do that will likely help to improve the Time To First Call of a particular product:

Extensive Documentation

At the risk of becoming a broken record, we’re back at it again, talking about the importance of great API documentation. The key to this is understanding your audience well enough to tell them what they need to know straight away, and highlighting that information appropriately, while covering what they might want to know at a later date elsewhere.

Demonstrate Use Cases and Examples

Maybe this could fit in the documentation section above, but we think it’s important enough to deserve its own paragraph: providing in-depth examples of what your API can do will help to capture some of those who are on the fence about whether or not it’s the right solution to their problem.

Assessing Roadblocks in the Process

The best example of a roadblock to TTFC is requiring manual approval before an API key is issued. It may not be a dealbreaker if you really need something like that in place, as long as approval is timely. If it’s not, you risk both losing out on potential users who were “on the fence” and upping your TTFC.

Encourage Making Calls Early

This (probably) isn’t as simple as directly telling people, “hey, time to start calling!” However, it might help to provide sandbox environments and highlight how the API reacts to what different users will do with it. Then, they’ll know exactly what to expect when they call it.

Consider the Role of External Tools

Postman public workspaces, first introduced in 2020, have been described as the first “massively multiplayer API experience.” The Joyce Lin article linked above mentions two case studies that cover Vonage and Symbl.ai’s efforts to let users explore their APIs before making calls.

Writing for Nordic APIs, Derric Gilling previously called Time To First Hello World a north star metric for measuring developer relations. Acting on the points above should reduce TTFC, though it may not do so immediately, and that’s extremely valuable.

A lower TTFC is generally associated with a better developer experience, which usually equates to better user retention, more customers (and revenue), and a more robust API offering as a whole.

The Evolution of Time To First Call

In the past, we’ve written about the rise of low-code/no-code tools and the impact that increased API control might have on future adoption in the space. We’ve also touched on the part external tools can play in lowering TTFC above.

The process of people hooking up with your API via a third-party service, rather than going directly through your developer portal, might look different than you’re used to. Still, it could be valuable when it comes to lowering barriers associated with your API.

Although the future of APIs likely isn’t (just) making calls to services found in extensive directories via third-party services like IFTTT or Zapier, it will almost certainly be a part of it. It’s worth thinking about that eventuality sooner rather than later.

In the meantime, however, there’s more than enough to get to work on when it comes to lowering your TTFC and, ultimately, improving the extent to which people engage with your API.