Popular low-code and no-code tools such as Thunkable, Bubble, and Webflow are becoming increasingly adopted as businesses look to streamline their workflows and reduce costs. However, without adequate documentation, these tools are at risk of losing adoption quickly.
We chatted with Senior Product Manager, Wil Kirwan, to explore the underserved market of low code and no code solutions and how to drive API adoption through high-quality documentation (p.s. If you’re looking for a solid docs tool to get you started, check us out).
The Difference With Low Code Developers
It’s important to recognize that low-code developers (also called citizen developers) are not your typical software developers. Oftentimes, they have another job in the organization but are still building very useful tools and driving the adoption of your APIs to build those tools. An example that Kirwan used was a citizen developer creating a license plate recognition app for a parking garage. He didn’t set out to create an API, but he ended up needing one to complete the challenge he was facing to link the ticket to a specific garage.
Now, just because they’re developing and consuming APIs doesn’t mean that they understand the importance of documenting those APIs like a typical software developer would maybe think to do. If you don’t document how those APIs interact, you’re especially missing out on a giant opportunity to scale.
“While some developers won’t always figure things out on their own, if you give them a few use cases that are well documented, they’ll think of multiple ways to use your APIs and apply them to their other low code projects,” shares Kirwan.
How to Lure the Low Code Developer
The best way to avoid alienating low-code developers is by providing rich documentation with pictures and flowcharts. Why all the other forms of media? Kirwan explains, “This type of documentation is useful for less technical users and helps them understand the defined relationship between APIs.”
One of the biggest issues with API documentation is that it often stops at the “send a request, get a result” stage. However, effective documentation should go beyond this and provide a step-by-step guide to help developers navigate the entire API lifecycle. For example, the documentation for an EV charging vendor could include flow charts, all endpoints, and step-by-step instructions to start an EV charger. This level of detail makes the documentation more useful and increases adoption.
If you look closely within your own organization, you may find you already have this type of documentation in-house, and it’s just a matter of externalizing it. This is where you can tap into your customer team, marketing team, UI team, and graphics teammates to spread the word about such a valuable resource to your citizen developers.
“Multi-media documentation can make a huge difference in consumption and what low code developers get out of your APIs,” shared Kirwan.
Garnering Adoption
Choose Wisely for Integration Opportunity
Low code tools like Webflow, Bubble, and Thunkable have huge audiences and API connectors with them. When you get a devoted user community around these tools, low-code developers will begin to build plugins to work on that platform, thus adding another entrance point to the adoption of a product.
Kirwan explains that if we’re using the same example as before, creating an access token for an EV charger should be easy and straightforward. Don’t hesitate to look at low-code tools that exist out there. You can search for low-code app development and find many results, but be sure to select one that has easy integration opportunities. The more integrations, the better to create more points of entry and stickier users.
Make Automation Easy
Another thing about Low code developers is that they have a need to automate everything they can, even if they’re not the most technical people in the world. Make adoption of your API product simpler by providing solid documentation upfront so that they can plug and play and automate to their heart’s desire. Established documentation also frees up other developers to focus on things that require more innovation and creativity.
Increase API Visibility and Create an API Catalog
To make adoption more feasible, take an inventory of how your APIs interact with each other and who is consuming, not just your APIs but also your API documentation. As we discussed above, good docs are your first step, and making your APIs useful by providing a set of use cases that any person picking up one of these low-code tools could do as a sample project while learning that tool will help. The audience using low code or no code tools is not as technical as a software developer understanding every nuance.
Once you have your APIs and your docs, make them visible and find ways to increase discoverability to not lose track of all that you have. An API catalog is a great way to increase visibility and discoverability within your API program and the docs you have available.
Don’t Forget About API Security
Low code developers are building these tools because they want to go fast, but one concern is always going to be API security in the process. Make that process as easy as possible to encourage that citizen developer’s interest by considering using API keys, authentication, and other security measures that enforce security without being a huge barrier. And as always, a solid security review is essential.
In the End
App sprawl with low code and no code tools can quickly become a problem if you’re not carefully minding your program as a whole, but for the most part, they can be a great ecosystem to tap into for more adoption and consumption of your API products.
But, to do it right and to keep them coming back, documentation quality plays a critical role in driving API adoption. With more low-code and no-code solutions entering the market, it’s essential to recognize the underserved market of citizen developers and eliminate any barriers that may leave a sour taste in their mouths!
