How an API Platform dramatically reduces development costs when scaling
API Integration Maintenance Overview
Whenever a third-party API is integrated with an application, long-term maintenance concerns arise. These concerns can be different depending upon whether a direct integration is performed or a middleware layer is deployed between the application and the third-party API, and the differences can factor when deciding which approach to pursue. In this article, we’ll provide an overview of API Integration Maintenance, and some things to consider when integrating.
API Integration Maintenance Basics
Virtually without exception, a webservice interface is a living thing that evolves over time. The adage of ‘if it ain’t broke, don’t fix it’ seldom applies in the realm of IT, and particularly when consuming a third-party webservice you should expect that its maintainer will be updating it at least semi-regularly and generally without regard to your preferences as a consumer of their service.
For the most part, API updates will fall under a small handful of broad categories:
- New Features – Additional API endpoints that perform new functions, support for new parameters or output formats on existing API’s, etc.
- Performance Improvements – ‘Under the covers’ changes to existing API endpoints, for instance, to reduce request processing time, allow more data to be queried in a single request, etc.
- Security Fixes – Updates to existing API endpoints or response data to address confirmed or possible security vulnerabilities
While a quality webservice operator will often be able to introduce new features and performance improvements without breaking backwards compatibility, this may not always be the case. And even the best operator will introduce breaking changes to their API if doing so is the only way to address a known security exploit.
Thus when integrating with an API, it’s important to monitor it periodically both for breaking changes that require updates to your integration code as well as for new features that you want to take advantage of. Failure to do so or failure to respond to any breaking changes with a prompt integration update can lead to sudden breakages of your application as third-party endpoints are removed, relocated, and refactored.
The great news about the Doshii platform is that we guarantee backward compatibility. We always continue to develop and advance our API integration service, but at the same time making sure to support older features. We also follow a structured versioning roadmap, to minimise the impact on developers and make sure there is no confusion over our releases.
We discuss upcoming releases in our community forum, and developers have input into what features they’d like to see. The ideas and feedback submitted through our community forum have been invaluable and have become an important part of our development strategy. We practice abstraction across all subscribers to avoid the duplication of developer effort, and provide certification and clear terms of service. All to make our partners’ lives easier.
When integrating directly from your application to third-party APIs, scalability of your maintenance tasks becomes an important concern.
It’s good practice to monitor for any changes or enhancements to APIs to avoid breakages and allows your system to benefit from those changes. This applies to each API you integrate with; as you add more integrations your monitoring overhead increases, as does the frequency at which you’ll need to update your application code to remain current with each API, and the amount of time you’ll have to spend implementing those updates.
If you don’t keep ahead of API changes, you may find yourself scrambling to fix unexpected breakages as deprecated functionality is removed from third-party APIs.
Points to Consider:
- Can respond to API changes immediately, taking advantage of new features as quickly as you’re able
- Low architectural complexity, which you are fully free (and responsible) to control
- Reduced hosting/operational/service costs
- Development overhead grows linearly as more API integrations are added
- All clients must install/update to the new version to benefit from changes or bugfixes
- Sudden breakages are more difficult to address quickly
- Backwards compatibility may not be supported by all API providers
- API integration support is not guaranteed and must often be managed in-house
When running a middleware layer between your application and the APIs you consume, the maintenance landscape is slightly different. The middleware layer provides a natural place to preempt breaking changes, at least temporarily, making these tasks slightly less urgent. For instance, if a third-party endpoint has suddenly disappeared, a quick patch to the middleware instance to stub out calls to this endpoint and return some ‘harmless’ default value (such as an empty result-set) can safeguard things until a more proper fix can be developed and deployed.
This mitigates (although not completely) against client-side disruptions and allows you to implement a proper fix at your own pace. Often such fixes can be implemented purely in the middleware, avoiding the need to push an update to your actual client endpoints.
The same approach can also be used to take advantage of new features and performance fixes. In many cases, such changes can be implemented in the middleware without requiring any client-side changes.
Furthermore, If you’re using a third-party middleware layer, such as Doshii, then your maintenance concerns almost disappear.
You still have to keep your Doshii integration current, of course, but everything else becomes Doshii’s responsibility. Doshii will monitor supported third-party APIs for updates and implement the necessary changes on their end. You just need to monitor one API for one set of updates, regardless of how many different third-party APIs you ultimately access through Doshii!
Points to Consider:
- Development overhead is constant no matter how many third-party APIs your app consumes
- New features can often be deployed without requiring a client update
- Sudden breakages are avoided, in cases where the middleware provider maintains backwards compatibility (as, e.g., Doshii does)
- Provides access to experienced external support and advice for new API integrations and testing
- Provides access to community and self-help resources, for any well-established middleware provider
- New API features provided by integration partners are only available once they’ve been implemented by the middleware provider
- Middleware integration costs will likely apply
- Access to new integration partners without any additional development effort