How a Low-Code API Platform Delivers Developer Productivity

Nothing strikes fear into the hearts of developers like the terms no-code and low-code (except maybe AI). DevOps has us wanting to move fast and automate everything, but we don’t want low-code platforms to replace developers' jobs! 

In reality, like most things in tech, it’s poorly named. Especially in the API space, low-code is actually a facilitator that increases both developer productivity and systems reliability. Most importantly, it allows developers to better embrace their roles as creative knowledge workers. You can quit working on repetitive, frustrating work and focus on real value drivers! 

The Enterprise-Grade Problem of API Sprawl

IDC pegs that, by the end of 2022, 90% of new digital services will be built via application programming interfaces. And yet, as Red Hat’s Holly Cummins recently said, “We dream that, with microservices, things become decoupled but sometimes they become more tightly coupled. Distributed and decoupled are not synonyms.”

In reality, the more distributed your systems are, the larger your organization is, and the more you leverage third-party integrations, the more complex your stack and the more dependent you are on other people, data, and code. It gets even worse with how much open-source code organizations use. Most organizations don’t have visibility into their API sprawl, so they release quarterly instead of multiple times a day or even fortnightly. This is in contradiction to how your customers are demanding new features faster and faster. And it’s risky because these are significantly larger swaths of updates that are more likely to fail to integrate and yet are harder to roll back. Everybody’s up late on call.

This wide distribution of tools and teams makes enterprise decision making very slow with many touchpoints. And it sacrifices developer autonomy.

This all comes down to a lack of visibility among the heavily siloed teams, departments, and divisions. This leads to waste, building what’s already been built elsewhere in the company.

The cost of this developer productivity loss is staggering. 

The State of DevOps Report in 2021 found that limited automation around repetitive tasks meets a lack of self-service platforms, together jeopardizing quality, speed, and scale. The 2021 Google Cloud State of API Economy Report found that this lack of centralized API governance directly triggers concerns around stability, scalability, compliance, and security. In the book Designing Web APIs, the authors revealed that a lack of consistent API design enforcement and no unified developer experience means developer productivity suffers dramatically. Most humbling, the average developer wastes more than 17 hours a week on debugging and refactoring inconsistent code. All this boils down to about $300 billion in lost productivity annually!

Low Code Is Like Autocorrect for the Next Time

This decoupled status quo doesn’t just slow down the release cycle, it means developers are working on repetitive work. A survey of 600 engineers had them reflect on what they wish they could spend less time on:

• Manual testing of changes/writing scripts: 37%
• Refactoring old code: 35%
• Writing code for new features: 33%

Only one of those activities is really delivering business value to the customer. Enterprises are facing an overwhelming tool stack with a huge talent investment and many bottlenecks slowing down decision-making and feature releases along with disjointed communication across teams. The work is hugely custom and manual, from scripts all the way through unstable releases. Enterprises are going through lengthy, expensive recruitment processes to supplement bad code instead of investing in tooling. 

During the time of the Great Resignation, this becomes a huge problem. As developers, we always like to wake up to a new challenge. We are creative workers and demand new problems, tools, and use cases. We yearn to be more connected to business value. The only way to achieve that is by automating as much of our work as possible. 

By embracing centralized API governance, you can templatize and reuse APIs for similar use cases across an entire organization, just customizing when necessary. This creates consistency and predictability throughout the organization — from fields all the way through to response codes. No more repeating the same mistakes. This level of automation is supported by specification-driven API development, which means better, more automated documentation — no more going in blindly or connecting to an API that’s not fit for purpose! 

By enabling low-code API development, you can automate the best practices throughout the API lifecycle. It also enables more cross-functional, cross-organizational collaboration, with everyone aligned, making it easier to connect tech moves to business goals. It helps meet increasing enterprise demand for visibility and security at each interaction point — automated guardrails that make sure that only APIs meeting a certain level of quality and security are released.

APIs are the logical place in your stack to start your developer automation journey. This move toward centralized API governance has been clocked at improving developer productivity by an average of 65%. 

Overall, a centralized API management approach reduces time to market through standardization, reliability, reusability, and automation. Most importantly, it increases developer satisfaction. 

One API Platform to Rule Them All

As WriteOps founder Chris Cooney wrote on DZone recently, “DevOps productivity is a real problem, but low code might be the next big step in boosting your productivity, increasing your focus, and delivering value” [Read here: Increase Your DevOps Productivity Using Infrastructure as Low Code].

The IDC report mentioned earlier also predicted that, within the next two years, 70% of enterprises will reduce the cost and complexity of customizing enterprise applications by investing in platforms. Combine these two observations and it’s clear: The future is low-code and platform-driven.

An API management platform is emerging as the solution to these repeated problems of lack of time, lack of know-how, and increasing complexity. A single platform abstracts out complexity, allowing developers to not have to log into ten different tools or interact with ten different teams. With the right API management tool, you as a team can create a purpose-built workflow or leverage integrations to use the tools that you already like to use.

What matters to most enterprises is that a platform-based approach to APIs means consistency and visibility — something governance, risk, compliance, and security teams particularly like to see. And developers like that they still have relative tool choice and release autonomy, while working on significant and interesting problems. This way low code becomes less a harbinger for job automation and more a natural way to rid your job of the boring bits.