So what are microAPIs?

Background

For major part of 2020 and some part of 2021, I was building Microapps.

"Microapps are small, task-specific applications that deliver highly targeted functionality. These apps allow users to accomplish single-purpose activities in a simple and quick manner. Microapps deliver actionable forms and notifications. Microapps can write back to source systems."

Microapp is a simple, easy to use and powerful construct which gives you a very specific capability - either an action you can perform or notification you can receive. For ex. consider a microapp to apply PTO in Workday, create a lead in Salesforce or receive a notification for approving a PR in Github. Yes you can do all this by logging in to the respective app on your mobile or desktop but that is more work to do and more context switching for each such task. Microapps lets you do the work in a unified, simple and targeted way.

How do microapps work?

They work by leveraging the APIs of the underlying services.

So what microapps essentially do is abstract the complexities of underlying APIs and surface consistent, easy to use, targeted GUI to the user to get their work done.

And that brings me back to the original question.

What are microAPIs?

Before answering that, couple of points for information:

1. It's not an industry standard term (yet) and is something I coined and used for communicating my ideas internally.
2. Lukas Rosenstock has defined and used the keyword in his 2017 blogpost here. As we shall soon see, his idea while similar to mine is some respect, focuses more on the technical implementation details whereas I'm looking at it from a value proposition (outside in/usecase oriented) perspective.

Finally!! the stage is set for answering the question - What are micro APIs?

Think of the value proposition (simple, consistent, targeted) of microapps but instead of positioning it at the level of GUI, position it one level down at the level of APIs. MicroAPIs are small, task-specific, consistent APIs which deliver highly targeted functionality. These microAPIs allow developers to accomplish single-purpose activities in a simple and quick manner.

By implication, microAPIs are single-responsibility, use-case driven, small and simple APIs which give a consistent experience to developers using them.

And that's VERY POWERFUL! When you have microAPIs you can build microapps using them but you are not limited to that. It allows for more innovation and more ways of monetization.

Sounds interesting - Tell me more

I learned few things while building microapps for Webex, Kronos, Workday, etc.

APIs of underlying services not easily consumable in microapps due to

• Format (xml, soap, json...)
• Shape (structure, data types, ...)
• Auth mechanism
• Minimalism vs Verbosity
• Need to orchestrate multiple calls
• ...

What is needed

• APIs which are easily consumable in microapps
• Expose exactly what is needed to achieve the use-case
• In a simplified format
• Do it in a consistent way

MicroAPI is

• Subset of underlying service API
• Use-case specific
• Custom crafted for microapp consumption
• Lean/minimal data
• Simple to use
• Consistent with other microAPIs

Example MicroAPI - Workday - Apply PTO

To appreciate the MicroAPI fully one needs to first hand experience what it takes to apply PTO using the Workday SOAP APIs which was the only option available when I was exploring it in 2020. But delving into that is beyond the scope of this post. Here we look at the microAPIs directly.

Given a choice to use microAPIs, no developer would like to use the "raw" service APIs to achieve the same usecase.

Demo of microAPI using a custom built microUI

• The PoC micro API was implemented using Node.js
• More elaborate implementation used Azure API Gateway for rate limiting, URL abstraction etc. and Azure Functions to host the Node.js code.

In conclusion

While tons of APIs are out there, not all of them are simple, targeted to specific usecases, and consistent with each other. This creates a cognitive overload and steep learning curve (and therefore a barrier to entry) for developers who are new to the API and just care about getting their usecases implemented in the shortest possible time. And this problem can be solved. With microAPIs.