Scaling API Management
Overview
Yappes is an API lifecycle management platform designed for developers managing high-scale ecosystems. One of my key tasks was implementing the Transformation Policy feature. Established competitors like Kong and Apigee already supported this feature, making it a baseline expectation for enterprise API management platforms.
This capability was introduced as a configurable extension within the existing policy management system, enabling users to modify headers, query parameters, and body content at both request and response levels. The feature was seamlessly integrated into the legacy UI, maintaining design consistency. It was delivered in alignment with the product roadmap, ensuring minimal disruption to engineering velocity while enhancing policy flexibility.
My role in Yappes
Senior UI/UX Designer - Yappes Technologies Pvt Ltd
I led the end-to-end product design for Yappes’ API management system. Building a scalable design system, designing complex features like transformation and advance routing across multiple API protocols.
Ensuring a seamless developer experience through research, consistent cross-platform workflows, detailed prototyping, and rigorous validation via CURL, API tryouts & user flow testing.
Design Sprints Process
Considering timeline and product roadmap, adopted a design sprint structure. This allowed rapid discovery, validation, and iteration while keeping the design effort aligned with engineering sprints and delivery.
Problem statement
How can we adapt the API transformation feature and scale its configuration across APIs without disrupting the legacy UI or adding friction for developers?
As APIs scale, developers need clear, fine-grained control over request and response transformations. Yappes supports basic endpoint-level policies, but scaling this flexibly without adding complexity remains the core challenge.
Focus & Goals
Desk Research
Understanding Transformation feature in API Management
APIs help in communication between two systems or applications. An API management system sits between the client and backend service, acting as a control layer that handles requests, enforces policies, and ensures secure and reliable interactions.
One of the critical capabilities in managing APIs is Transformation. This feature allows platform users to manipulate the data flowing through APIs, ensuring compatibility, security, and clarity between systems without changing the underlying service.
Transformation can be categorised into two types:
Request Transformation - Applied before the request reaches the backend from client.
Response Transformation - Applied after receiving the backend’s response but before it reaches the client.
End-to-End API Transformation Technical workflow
Why Transformation Matters?
Reduces backend dependency. It helps bridge gaps between frontend and backend by adapting data formats, field names, headers, URLs, query parameters, and even HTTP methods all without changing backend logic.
Common use cases include:
Customising payloads for frontend frameworks
Masking or removing sensitive data for compliance
Mapping partner data fields for easier integration
Serving region-specific content based on request metadata
Understanding what the product needs
To understand the scope and expectations for implementing new feature, interviews were conducted with key stakeholders including the Engineering VP, Backend Engineer, Gateway Engineer and the Frontend Team. The following insights emerged:
Competitive Benchmarking
Industry Approaches to Transformation Features
To contextualise Yappes’ implementation, I benchmarked leading platforms based on API transformation support:
This benchmarking reveals common trends in how transformation is handled.
Platforms support a mix of declarative and programmatic (script-based) approaches.
Most provide transformation at multiple levels API, route, service, or environment.
Common scopes include header, query param, and body manipulation.
These findings informed architectural strategies by strengths like plugin flexibility, declarative control, and interface clarity.
Insights & Challenges
Insights from understand phase
Key Challenges
Leaders focused on scaling within current UI and keeping dev velocity high.
Policy management system
Current gateway policy management system
The API Gateway manages policies at both the API and subscription levels.
When a request is made, the gateway checks for any attached policies like routing, load balancing, mocking, or caching before forwarding the request to the backend.
Each feature is configured using policy settings. These reusable configurations are applied to APIs to ensure consistent, automated handling of requests and responses.
Solution Sketching
Flow for Transformation Policy Attachment
This flow outlines how users navigate from selecting an API to configuring request or response transformations within existing policy workflows.
Wireframes
Detailed IA & wireframe flows
Finalise Solution
Final Design
The solution was refined through multiple product and engineering reviews to validate ideas, flows, and wireframes.
Creating and attaching multiple transformation policies per endpoint
Reordering policies to control execution flow
Supporting header, query, and body transformations for both requests and responses
Preventing errors through validations and smart configuration controls
Enabling advanced use cases with script-based body transformations
This approach balanced flexibility with usability while maintaining development velocity and UI consistency.
Testing Phase & Validation
Testing transformation feature
The transformation feature was validated through a two-step testing process.
First, UI-level testing was conducted to verify configuration flows, edge cases, and error handling.
Next, API-level testing was performed using API try-out tools and
curlto ensure the transformations really occurred at gateway level.
Both UI and API test results were reviewed collaboratively with engineers to confirm correctness, performance, and alignment with backend behaviour. This validation ensured that transformations configured and executed correctly at the gateway level.
Key Learning
This project deepened my understanding of designing complex, system-level features within an enterprise API management platform.
Note
Designing API management features showed the importance of combining technical understanding with clear, scalable UX, turning backend logic into intuitive workflows.
At Yappes, I’ve delivered and tested over 16 platform features in the last two years, gaining hands-on knowledge of API behaviour, gateway operations, and real-world usage patterns.