As your enterprise scales, API complexity can creep up on you fast. Disparate teams, each with their own approach, new technologies adopted in silos, mergers that bring whole new systems in-house, different API protocols used for different purposes… all of this and more contributes to API complexity. The result is security vulnerabilities, operational inefficiencies, wasted resources, difficulty scaling, and compliance headaches. Instead of helping achieve your business goals, your API architecture can become a major distraction from them.
It’s rather a gloomy picture, but it’s the reality that many enterprises are currently grappling with. If your organization is one of them, fear not – there is hope in sight! Based on the recent LEAP 2.0 API Governance Conference (watch it on demand here if you missed it live), we’ve pulled together five lessons from enterprises that battled API complexity and won.
Key problems and resolutions
Panelists at the LEAP 2.0 conference shared a range of key problems, and resolutions relating to API complexity. One key problem, according to Tyk Cofounder and COO James Hirst, is that API governance needs an image overhaul. Having worked with major banks, cutting edge consumer technology businesses, the automotive industry, theme parks, telcos, travel businesses and more, he has seen a wide variety of approaches to governance first-hand. He’s also realized just how many teams view governance as complex and burdensome. However, implementing it is the first of our essential lessons in fixing API complexity…
1.Implement a universal governance framework
If you want to get the best from your APIs – and your wider business – then establishing a universal governance framework is crucial. To manage the increasing complexity of your APIs as you scale, you’ll need a governance framework that encompasses security, compliance, and strategic alignment, ensuring consistency across diverse API protocols, platforms, and teams.
Implementing a universal governance framework that achieves all this isn’t complex and burdensome. In fact, the best API governance strategy just might be a boring one. It needs to be easy to understand, follow, measure and report on, including reporting on return on investment (ROI).
Atlassian provides a good example of this latter point, demonstrating the value of API governance to organizational outcomes. The organization used broken client integrations as a governance metric, showing how the reduction in these for partners who used its APIs led to a clear improvement in those partners’ end experiences.
2. Adopt a federated API management approach
The second lesson in tackling API complexity lies in understanding the value of federated API management. LEAP 2.0 panelist Daniel Kocot, Head of API Consulting at codecentric AG, spoke about the importance of this. He explained that modern API management is about understanding what an organization really needs and what will add value as that business scales.
This is where federated API management is such a big win. It enables you to apply a single management and governance layer, under which you can have multiple API gateways from different vendors, various event brokers and repositories, and multiple deployment patterns and protocols. It’s the ideal balance between achieving everything you need to operate flexibly while scaling agilely and supporting disparate teams to innovate at pace, providing local autonomy within a global framework.
You can dive deeper into how you can govern federated API management effectively here.
3. Prioritize people
Panelist and author Bruno Pedro was keen to extol the virtues of ensuring your people understand your API governance if you want them to engage with it (which you really do!). He advises:
“Find a common element for what your API governance is delivering. Why are you doing API governance? What is it for? Once people understand, they can actually want to follow it instead of you having to make them.”
This is key to addressing the problem of people ignoring governance guardrails and finding workarounds – an approach which simply stacks up API complexity issues for later, rather than fixing them.
The solution is to focus on what people need from your APIs and your governance. That means focusing on the developer experience and the needs and challenges of API consumers when you design your APIs. It also means thinking about how you can better support people to reuse your APIs and other resources, and how you can free them to innovate without fear of breaking the business when you have the right governance framework in place.
On the design front, documentation, consistent design patterns and guidelines, and support foster positive and efficient processes, while an API style guide ensures consistency and makes integration more intuitive. You can reduce troubleshooting and support costs, enhancing the overall developer experience.
In terms of overall governance, putting people at the heart of your approach means engaging them early and designing processes that meet their needs, and make their working lives easier. You bring them on board and they collectively help reduce API complexity through a well-structured and standardized approach (that still leaves plenty of autonomy for innovation).
Common architecture challenges and resolutions
In addition to the above issues and solutions, LEAP 2.0 conference panelists shared their approaches to overcoming complexity from an architectural standpoint. Let’s consider a couple of lessons in relation to these.
4. Implement comprehensive API versioning and sunsetting policies
Another key lesson from an enterprise that fixed API complexity – financial services provider Northwestern Mutual – is to embrace an automated architecture for API provisioning and governance. This comprehensive approach covers the full API lifecycle, right through to API versioning and sunsetting policies, which are essential to ensuring that your APIs remain relevant, useful and up to date. You can watch Northwestern Mutual’s automated governance model in action here.
Managing API versions effectively involves setting clear policies for versioning and sunsetting, including defining expiry dates for API versions and providing clear deprecation notices. This ensures smooth transitions for consumers, as well as maintaining backward compatibility. In Northwestern Mutual’s case, automated retirement workflows not only helped control API architectural complexity, they also helped move customers along to better solutions.
5. Don’t start with an API governance platform – work towards one
The final lesson, as outlined by LaunchAny’s James Higginbotham, is the need to address your people and processes first when it comes to implementing API governance, then find a platform you can use as an enabler and an enforcer. Many enterprises approach this backwards, investing in a platform and then trying to shape their business to suit it. However, that approach won’t ensure your platform expresses your business as a topology of your IT capabilities and your business capabilities – which it needs to do.
Once you understand your people and processes, then it’s time to find the right platform to drive decision-making aligned with business goals. You can use it to gain competitive advantage through a structured, strategic approach, underpinned by the security, scalability and agility your enterprise needs to move beyond API complexity to confidence and consistency.
Steps you can take today
You can start to work towards fixing API complexity in your enterprise today. The first step is diving into The enterprise architect’s guide to universal API governance. This detailed guide serves as a blueprint for building clarity into complex systems. It demonstrates how you can scale APIs safely and strategically across teams, protocols and platforms, cutting through the complexity to use governance to power innovation and unlock your enterprise’s full potential.
