Why API Integrity is a "Must-Have" in the API Economy
By Mark Lambert, VP of Product Management, Parasoft
Modern applications are composite—aggregating and consuming private, partner, and public APIs at a staggering pace in order to attract and retain customers. ProgrammableWeb reports that there are over 12,000 APIs published today. Beyond these publically-exposed APIs, the number of private APIs isestimated to be in the millions. With the proliferation of mobile apps, the number of APIs is certain to escalate exponentially.
APIs represent the next phase of the internet land grab. Just like web sites promised consumers fast, efficient access to product and services, APIs will offer the business-to-business connections that expand brands within extensive ecosystems. This means that both the producers and consumers of APIs must be diligent in the service-level agreements (SLAs) that promote the business integration. Whereas SOA required “trust” for the consumption of services, the public and private incarnation of services—APIs —require integrity.
As the risks associated with application failure have broader business impacts, the integrity of the APIs you produce and consume is now more important than ever. An API that fails to deliver the expected level of security, reliability, and performance can thus have tremendous business impacts—both to the organization producing it and to those consuming it. With APIs, the weakest link in the chain can have significant process repercussions.
If you are integrating exposed APIs into your business-critical transactions, you are essentially assuming the risks associated that API's integrity (or lack thereof). As the number of external APIs integrated into a business process increases, so do the potential points of failure. The business impact of any application failure is the same, regardless of whether the fault lies within the components you developed or the APIs you are consuming. Finger pointing does little to foster customer satisfaction and brand loyalty.
If you are exposing an API, the assumption is that it will work as described. Once the organizations consuming that API integrate this exposed functionality into their own applications, API failure jeopardizes the transactions that now depend on this functionality. If your API is popular, you can guarantee that a glitch will make the headlines. The more secure, reliable, and dependable your API, the better the chance of consumption and the greater the potential for business expansion. If you’re providing a questionable interface and there are viable alternatives to your API, you’re likely to lose business since switching costs associated with API integration are so low.
As APIs grow in popularity to enable a broader array of online and mobile functionality, organizations must ensure API Integrity. With APIs as an enabler of—and potentially the weakest link in—critical business transactions, leading enterprises are recognizing that it's time to move beyond typical ad-hoc API testing and evolve a trusted, continuous testing process. Ultimately, leading organizations are finding that an enterprise-grade solution for hardening back-end services is now a "must have" for ensuring the security, reliability, and performance of critical transactions in today's API economy.
API Testing: Gartner Research
Now that APIs can make (or break) critical business transactions, leading enterprises are recognizing that it’s time to move beyond typical ad-hoc API testing and evolve a trusted, continuous testing process.
Read the API Testing package featuring Gartner research to learn:
- Why hardening back-end services is essential for the API Economy.
- API Integrity research findings: how buggy are APIs, what issues were most prevalent, and what is the business impact?
- How a global asset management company achieved a 20X reduction in API testing time as they transitioned to Agile.
- Gartner's recommendations for service/API testing.
Parasoft’s industry-leading automated software testing tools support the entire software development process, from when the developer writes the first line of code all the way through unit and functional testing, to performance and security testing, leveraging simulated test environments along the way.