What is an API developer experience? It sounds similar to user experience (UX), right? Almost – API developer experience (DX) is the practice of understanding how developers work, and more importantly, optimizing the experience they have through the whole lifecycle of an API. The developer experience has lately evolved from user experience because it sees developers as a special — and unfortunately — underrated case of user. Creating a positive experience for your developers is about understanding the context of how they use APIs, what developers need to complete their tasks, the underlying technology, integration points, and focusing on how developers feel while using the APIs.
Whether you are building your first APIs from scratch or already have a huge API ecosystem, catch up on these 10 best practices to improve your API developer experience.
Why is API developer experience important?
Think of every API you own as a product that you’re trying to sell. It’s not enough to create good products, or in this case API. Furthermore, the user of the product should feel as comfortable using those products. As developers become more comfortable using your APIs, the more they will use and promote your APIs, leading to more innovation, better customer experiences, and increased revenue.
What should my API design focus on?
API design is often concentrated into three siloed design factors:
Functionality first — a result of the service-oriented architecture, where the focus was designing the function and prioritizing what activities and actions need to be done. This determines what the API does and how well it is implemented.
The latest APIs focus on this, as it focuses on how the developers use the APIs, rather than what they use it for. However, functionality still trumps usability. No one is going to use your API, if it is usable but doesn’t solve the problem.
This is about how the API makes the developer feel during all interactions with your API ecosystem. This interaction starts with the landing page of your API portal, and encompasses developer onboarding, time to first API call, API documentation, support, API community and, of course, the use of your APIs.
The formula of success for API developer experience is to combine these three design factors. And don’t forget — even though we are building software, which is being used to build other software — we are still building a line of communication. Therefore, it is important to understand your developers before you start designing your APIs.
Achieving API developer experience with a balance of the design factors functionality, usability, and experience.
What can I do to boost my API developer experience?
Here are 10 simple things organizations can do to improve their API developer experience:
- Simplicity: Keep your APIs simple. Overcomplicating things might scare developers.
- Language: Speak the language your developers speak. Nelson Mandela once said: “If you talk to a man in a language he understands, that goes to his head. If you talk to him in his language, that goes to his heart.” Avoid marketing jargon and be clear about what developers can stop doing if they use your API.
- Onboarding: Make signing up for your API simple and fast. This includes easy management and fast provisioning of API keys. Have an authentication guide which shows the different authentication possibilities. Using flows or figures helps significantly.
- Time to first “hello world:” This one is crucial. From signup, it should not take more than five minutes for a developer to create the first “Hello World” app if you want them to use your APIs for real use cases.
- Documentation: Provide stellar automated documentation that is complete and up to date. This includes videos, tutorials, mocking services, and interactive documentation to make it easy to discover and learn APIs.
- Code samples: Provide clear and concise code samples in different programming languages. Meet your developers where they are and show them how a given task can be solved using your API in their preferred programming language.
- Limitations: Be clear about costs and limitations of your APIs. Provide free trials so your developers can play in a safe environment.
- Support: Have an FAQ and provide your developers with exceptional support. Make it easy for them to raise tickets or chat to get support when they encounter issues with your APIs.
- Community: Inspire developers and create a space for developers to engage with peers, developer evangelists, and API product teams through forums, chat or channels such as Stackoverflow, Twitter, and Facebook. Enable developers to publish answers to a public knowledge base or communicate privately.
- Measure: Measure the progress of your API developer experience and make changes accordingly. Common API developer experience KPIs include onboarding time, time to first hello world, requests per minute, average and max latency, errors per minute, developer logins, active apps, uptime and average support case response time. Besides launching KPIs you might run an API developer experience audit internally to grasp the status quo.
Where do I start?
A good way to start progressing your API developer experience is to ask yourself three simple questions:
- Does my API perform functions that developers are expecting it to do?
- How easy is it to use my API?
- How does my API make the developer feel?