Bhalla points out that (today, in 2022) there are a lot of The excitement and exaggeration about APIs and what they offer, what should we really think of when we think of their place in the modern IT stack and their space in the universe?
Bhalla writes as follows…
If we think about the needs of the modern end user, the API hype is understandable.
Consider mobile apps for calling, navigating, purchasing, checking the weather, and connecting to your employer’s business tools. The proliferation (and proliferation) of applications has forced application programming interfaces (APIs) to the fore to provide a degree of consistency and standardization. In addition, the needs of the user, be it the consumer or the business, are today more urgent than ever.
slow is the new down
If the user experience of these apps is negative, whether it’s connection delays or the app’s overall slowness, then those users will quickly switch to an alternative. The saying ‘slow is the new decline’. [i.e. we used to complain about downtime if a system were to crash and burn, but now we rank slow just as bad as a meltdown or crash] IIt is often touted when it comes to the end user’s experience and expectations, not to mention their demands.
This had an indirect effect on those responsible for developing these applications.
There is a constant race to offer greater and more diverse features and functions while simultaneously improving the user experience. APIs are at the heart of providing this. As a result, the APIs find themselves constantly being updated and upgraded. By the time a developer relies on a particular API, it is common that a newer version has already been released. This is particularly acute for open source APIs that have many contributors without a dominant organization to provide some degree of governance. The scenario is not different for browsers or operating systems where the end user finds that the version they have downloaded has already been overwritten by another later version.
This is often driven by developers striving for architectural purity.
Architectural purity API
Developers are constantly looking to improve the API in a piecemeal fashion to show a degree of responsiveness to the community they serve, and developers naturally strive for architectural purity.
Adopting agile development practices to “deliver less but more frequently” only exacerbates this situation. However, this can lead to a “blind spot” about the hands-on implementation and management of the API itself.
Considerations such as release cadence, handling of multiple versions, deprecation of redundant features, and the upgrade process itself are often an afterthought. Talk to any IT operator or system administrator, but… they’ll say this should be considered from the start as a priority. The pain of upgrade crashes, crashes, and configuration tweaks lead to a buildup of IT technical debts that are often under the radar of those who are not tasked with facing them.
Upgrading to the latest version of the API can also spread due to incompatibility with previous versions.
This reluctance to upgrade only doubles the technical debt that is accumulating. You want to upgrade your software, whether it’s a database, monitoring platform, service management group, or something else, without worrying that changing the behavior in the API will disrupt the front-end application serving end users. All software vendors have gone to great lengths to ensure that each version is backwards compatible, while also adding new features. However, even with this intention planned from the start, sometimes breaking compatibility was inevitable to fix certain issues or offer new capabilities.
Removing this pain point would be a huge boon. For those tasked with designing or procuring such technologies, identifying technology partners who anticipate this challenge and look forward to solving it for their clients will save themselves and their organization months of headaches later. Being the one who has avoided such a predicament will also be viewed favorably by the company more broadly, assuming this is sufficiently highlighted internally.
A subset of the “basic” commands
Identifying software vendors that enable frequent and seamless upgrades to take advantage of new capabilities (and yes, the inevitable bug fix or security update), while simultaneously protecting the enterprise’s past investments and work is key.
One way to do this for the database API is to create a subset of the “basic” commands that are frequently used to read and write data, create groups, indexes, etc. These commands are then prioritized and the engineering teams delivering API updates must ensure that they remain backward compatible in any new release. This set of commands can evolve as new features are added, but it must be implemented in a way that ensures backward compatibility. When combined with a rapid release approach, this gives customers the ability to adopt new functionality at a pace that their competitors cannot match, as they feel confident they can upgrade safely.
Regardless of who is selected as a technology partner, identify potential vendors who are actively aware that software is changing and at a steady pace with this, as well as the underlying APIs.
Expect this change in the API. Accept and accept that it will evolve in the coming years. With the expectations and demands of the end users, this is inevitable. Those who provide APIs should do so in a way that gives confidence. Only by instilling this trust will those organizations be in a position to benefit from the increasing cadence of new features and capabilities that the API offers. At this point comes the competitive advantage over competitors who are only beginning on this journey months or even years later.