To mitigate the cost, time, and waiting period associated with integrating with a suite of APIs, we, at Yubi, have developed a Low Code Framework. This article deep-dives into the process and fundamentals.
Introduction
Integrations serve as the vital link between multiple applications, enabling seamless data exchange through their APIs. They play a pivotal role in driving efficiency, revenue growth, and data synchronisation within thriving businesses. At Yubi, we prioritise integrations as a key component and a distinguishing factor, facilitating the seamless integration of various partners across our diverse ecosystem.
REST APIs dominate the landscape with a staggering 70% market share among public APIs. They stand out for their remarkable flexibility, easier learning curve, and direct utilisation through HTTP URLs, eliminating the need for XML dependencies.
Problem Statement
Integrating with a suite of APIs can be a significant investment, with costs varying depending on the complexity of the integration and the amount of time required from your developers.
In the LMS (Loan Management System) platform, each API integration with a lender (third party) typically involves a range of 15 to 30 APIs for every loan journey. This integration also encompasses a diverse range of API differences, such as variations in the accepted data structures (JSON or XML), calling separate API for borrowers, guarantors and co-applicants say, creating Customer Identification File in lender system, having a single API in which all of borrower, guarantor and co applicant details to be passed in array format resulting in a highly dynamic API structure. These are just a few examples of the complexities involved in the integration process.
Integrating with any system typically requires a significant manual effort to successfully complete, which largely depends on the complexity of the APIs involved. For a medium complexity API, it may take approximately 3 to 4 man days of effort to finalize, while a complex API could require 6 to 7 man days. Based on these estimates, a comprehensive integration project may typically require 2 to 3 months of effort to be completed successfully.
Low Code Framework (LCF)
To mitigate the cost, time, and waiting period associated with each integration, we have developed a Low Code Framework. This framework aims to streamline the integration process by utilising a visual development approach that requires minimal coding. With the Low Code Framework, the time and effort required for integration can be significantly reduced, enabling faster release of integrations to customers. This approach empowers businesses to efficiently integrate with lenders while minimising costs and reducing the overall time-to-market.
The Low Code Framework (LCF) was specifically designed to automate the code generation process and adopt a configuration-driven approach. This strategy allows businesses to configure various parameters and settings within the framework instead of manually writing extensive code. As a result, the integration process becomes more efficient and cost-effective. LCF accelerates the integration timeline, reduces expenses, and enhances overall productivity, making it a valuable tool for businesses seeking streamlined integration capabilities.
Core Logic
The fundamental principle behind the Low Code Framework (LCF) is that while every API may have unique characteristics, there are still common elements and patterns among them. LCF aims to identify and leverage these commonalities to provide a standardised and streamlined approach to integration.
Indeed, LCF was developed with a comprehensive understanding of the crucial elements found in every API, including header parameters, endpoints with potential dynamic values, request types and structures, as well as specific parameters that determine the success or failure of a response. These fundamental components serve as the building blocks of LCF’s design, empowering it to seamlessly handle the integration process. In LCF, the configuration is structured as a simple JSON format consisting of key-value pairs. The key represents the attribute expected by the lender, while the value is further divided into multiple key-value pairs containing attributes such as type and value which holds the logic for deriving the attribute value. This configuration approach allows for easy customisation and flexibility within the framework.
In the LCF framework, the input data is expected to be in JSON format, as it is designed to understand and process JSON data. However, to handle XML requests, once the necessary operations and transformations have been performed on the JSON data within LCF, to send the data to the lender in XML format, a conversion process is implemented. The JSON structure is then converted back into XML format before being passed on to the lender. This conversion step ensures compatibility between the JSON-based LCF framework and any XML-based requirements of the lender system, allowing for smooth data exchange and integration between the two systems.
In LCF, there are several predefined keys available for configuration. While the specific set of keys may vary depending on the api exposed by the lender, here are some commonly used ones:
| KEY/PARAMETER NAME | DESCRIPTION |
|---|---|
| api_name | To facilitate logging and enable easier debugging within the LCF framework, a mandatory input can be incorporated to track logs. This input typically consists of a unique combination of the lender's name and the API's name. By including this information, it becomes easier to identify and trace specific logs associated with a particular lender and API. |
| request_type | By specifying the request type as JSON or XML, the framework can appropriately handle the data and perform the necessary conversions or transformations if needed. |
| response_type | By specifying the type of response as JSON or XML, the integration system can handle and process the lender's response accordingly. |
| endpoint | In certain cases, the endpoint may need to be dynamic, meaning it can vary based on specific requirements. To accommodate such scenarios, the LCF framework supports dynamic endpoints by utilizing curly braces {} to enclose the dynamic values within the endpoint. The value part of the endpoint configuration will hold the necessary instructions or logic for deriving the dynamic value to be passed to the lender system. |
| headers | This configuration allows for specifying all the headers that need to be passed to the lenders. The key represents the header name as expected by the lenders, and the value holds the configuration for deriving the actual value to be passed to the lenders. |
| request | All the request parameters to be passed to the lenders can be configured in a flattened manner, where the key corresponds to the parameter name as expected by the lenders. If the parameter is nested within objects, the key parts are separated by a DOT (.), and in the case of arrays, they are separated by :0, :1, and so on. The value part of the configuration holds the instructions or logic for deriving the actual value to be passed to the lenders. It allows for dynamic value generation or retrieval from other sources within the integration process. |
| response | The response configuration helps in determining whether an API request is successful or a failure. The configuration allows for defining various scenarios and conditions to determine the outcome of the response. To configure the response, all keys are flattened and then specified in the configuration. Nested JSONs are separated by a DOT (.), and arrays are configured similarly using DOT (.) notation with indexes such as 0, 1, and so on. The configuration can include conditions, comparisons, or logic to evaluate the response and determine its success or failure status. This flexibility allows for customization based on the specific requirements of the integration. Additionally, the LCF framework provides the provision to save specific attributes from the response. This allows for extracting and storing relevant data from the response for further processing or analysis within the integration system. |
| success_completion_hook | Once an API is determined to be successful based on the response configuration, post-actions on the loan can be configured. These post-actions define the tasks or operations to be performed on the loan after it has been approved. One example of a post-action could be approving a loan. This means that when the API response indicates success, the framework can be configured to automatically trigger the approval process for the loan within the integration system. This could involve updating the loan status, notifying relevant parties, generating necessary documentation, or performing any other required actions associated with loan approval. |
| failure_completion_hook | When an API is determined to be a failure based on the response configuration, post-actions on the loan can be configured to handle this scenario. Examples of post-actions for failed API responses could include: Updating the loan status to indicate the failure. Logging the error details for further analysis and troubleshooting. Notifying relevant stakeholders or support teams about the failure. Initiating a retry mechanism or triggering an alternative integration flow. Generating error reports or notifications to inform administrators or system administrators about the failure. |
The LCF framework addresses the challenge of value generation, which can vary for every loan and API, by providing predefined functions to handle various scenarios. These functions help solve the following problem statements:
- Retrieval of Global Values: The LCF framework provides a streamlined approach for retrieving values from various sources, including environment variables, configuration files, and global variables. This feature enables the seamless retrieval of necessary data, allowing for dynamic configuration and adaptability based on specific runtime conditions or settings.
- Database Value Retrieval: LCF enables fetching values directly from a database, providing integration with existing data sources. This functionality allows for dynamic retrieval of information specific to each loan.
- Dynamic Function Invocation and Result Mapping: LCF supports the execution of custom functions and mapping the output to a specific key. This enables the utilisation of complex logic or calculations to derive values dynamically during the integration process.
- Master Data Handling and Value Derivation: LCF includes features to handle master data and perform operations like deriving branch codes or bank codes from IFSC (Indian Financial System Code). This simplifies the handling of reference data and the generation of values based on specific rules or algorithms.
- Dynamic Array Handling: LCF provides mechanisms to handle dynamic arrays and repetitive blocks of code, accommodating scenarios where the number of co-applicants or guarantors can vary. This ensures flexibility in integrating with lenders who require multiple entities in their API requests.
- Static Array Handling: LCF also supports static array logics, allowing for the repetition of a block of code for a predetermined number of times. This can be useful in situations where a fixed number of iterations or repetitions is required.
- Data Type Conversion: LCF includes functions to convert the data type of a value, facilitating the transformation or formatting of data as needed for the integration process.
- Handling special characters: The framework provides functionality to remove special characters from a value, ensuring compliance with specific data requirements or formatting guidelines.
- Setting a maximum length for a value: LCF allows for setting a maximum length or character limit for a value being passed to a lender. This ensures adherence to any restrictions or constraints imposed by the lender’s API specifications.
- Dynamic Generation of Unique Identifiers, Dates, and Epoch Time : LCF supports the dynamic generation of values like unique 36-character identifiers, date and time values, epoch time, and other dynamic data. This enables the integration system to generate unique and time-sensitive information required by the lenders.
By incorporating these predefined functions and features, the LCF framework offers a robust solution for value generation, addressing the diverse requirements and complexities involved in the integration process.
