Image background
Unak footer image background

GraphQL API for client facing integrationCredit Management


The client had banking software, which facilitates the work of banking systems and operators by introducing a custom-tailored workflow. The challenge for such a product was synchronising data between the banking systems and the software. To be more specific, the client system requires a specific set of data to perform its operations and services. Therefore, Qaiware’s role was to figure out a way and introduce a user-friendly integration journey by utilising the latest technologies.


> Legacy system operating under monolithic architecture
> Complex database model design
> Custom ORM
> The integration journey required multiple sources of data, which cannot be provided in a single call
> Asynchronous processing of integrator’s request with the queue system
> The monolithic architecture was not designed to support simple API calls due to complexity and processing delays


  • API Gateway
    • What we did > Design, implement, and deploy a new integrator-facing component which facilitates the exchange of messages and acts as a request validator with a persistence mechanism.
    • The value > By introducing this intermediate component, Qaiware allowed the integrators of the banking software to access its data objects as simple API requests. The synchronisation between the API Gateway and the banking software provided the necessary bridge to update information on demand and keep all persisted data up-to-date.
  • Automatically generated GraphQL API
    • What we did > Due to the design and implementation of the client’s banking software, an automated UML modelling tool was used to generate the entire database. The client wanted to introduce a GraphQL API to its integrators, which will allow them to create, update. delete, and retrieve objects from the database. However, the sheer amount of objects supported made manual development unfeasible. Therefore, Qaiware’s solution was to use the provided UML models and generate an entire GraphQL API.
    • The value > By using the client’s database models, Qaiware was able to create the necessary components required. In a short amount of time, the integrators had an entire working GraphQL API with more than 100 queries and mutations, custom error messages, schema validations, and persistence.
  • Custom executable functions
    • What we did > During the design of the GraphQL API, it was determined that specific business functions must be executed during the request processing. In order to fulfil this requirement, Qaiware’s teams analyzed, developed, and deployed a number of methods and functions, which on the client’s request can be activated during a specific GraphQL mutation or query.
    • The value > Fulfilling this requirement provided the client with the flexibility to customize their GraphQL API without having to update any GraphQL executable files. It gave them the freedom to satisfy any new integrator’s requirement and still retain the overall GraphQL flexibility.
  • Unified error handling
    • What we did > During the initial analysis of the client’s monolithic application, Qaiware discovered a lack of clear and well defined error handling. Therefore, we proposed introducing common error handling (format, content, context).
    • The value > With common error handling and shared error messages, the integration journey is simplified and consistent throughout the different phases. It reduces the overall time and assistance required from the client′s side to solve integrator’s technical issues.


  • Each team member was familiar with asynchronous request processing, GraphQL design and implementation, and a common understanding of the integration journey.
  • Qaiware provided two fully staffed teams and a Delivery Manager to organise the software delivery.


> Java
> Spring Boot
> GraphQL API


Similar Articles