Mentors

Rajan Maurya Chinmay Kulkarni Shashank Priyadarshi

Length

Large - 350 hours

Category

Mobile - Android SDK | Kotlin Multiplatform

Overview & Objectives

The goal of this project is to migrate Android field officer kotlin multi-module application to Kotlin Multiplatform and rewrite network layer by adopting fineract-client-kmp-sdk, make all the network calls are working as expected. The Android client will be the first of the Mifos mobile apps which consume the SDK, reducing repeated network layer code in mobile apps, improving developer experience, and making it easier to migrate to newer versions of Apache Fineract 1.x and Student would work on designing offline sync functionality in background.

This year we are totally focusing on migrating to Kotlin Multiplatform, writing Unit and Instrumentation test and writing github actions to automate release process using fastlane.

Description

In 2025, The student will be working on implementing the following things:

1. Update the Android client to latest dependencies

2. Rewrite Network layer of Android client to consume fineract SDK using coroutines instead of RxJava implemented code.

3. Migrate kotlin multi-module codebase to Kotlin Multiplatform

4. Write appropiate unit and integration tests.

5. Update CI/CD to build APK and analyses code quality

6. Implemented Playstore release github action pipeline

7. Integrate google playstore API for better and faster release flow.

8. Update corresponding documentation for building the app.

Helpful Skills

Android, Kotlin Multiplatform, Kotlin, Jetpack compose, navigation-compose, MVVM, coroutines, Flow, multi-module architecture.

Impact

1. High performance using jetpack compose

2. Clean code and easy understandable code because of multi-module and coroutines implementation.

3. Kotlin Multiplatform support to build application for Android, IOS, Desktop, Web.

4. Overall stability by increased testing coverage through a more stable and error-free codebase.

5. Improved developer experience through faster build time.

6. More seamless release management and upstream contribution

7. Reduction of time to upgrade

Other Resources

QA & Testing - https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=195730042

2024 GSOC Final Report (Aditya Gupta): https://gist.github.com/Aditya-gupta99/f0bad77037ae76f32dddb933b6cb1c2a

Github

https://github.com/openMF/android-client

https://github.com/apache/fineract

https://github.com/openMF/fineract-client

https://github.com/openMF/fineract-android-sdk

Mentors

Rajan Maurya Avinash Vijayvargiya

Length

Large - 350 hours

Category

Mobile - Mifos X | Core Development

Overview & Objectives

2025 development will focus on refining our current Mobile Wallet to be a strong reference implementation of feature-rich and secure mobile wallet application for G2P use cases. While our mobile wallet is a powerful tool for all fintechs and financial institutions, we want to powerfully and simply demonstrate the ability for governments to disburse G2P Payments to highly functional mobile wallet and then be able to transact with that wallet by paying for bills, sending transfers, and paying for goods and services via merchants. We provide a reference mobile wallet application for consumers and merchants that has been developed by our Google Summer of Code interns from 2017 to 2024. The mobile wallet provides an extensible mobile wallet framework to support the basic use cases of a mobile wallet as documented in the Level One Project mobile wallet requirements. This extensible framework should support both merchant and client use cases as well as be capable of integrating with a Fineract back-end

Over time, we would like Mifos X to be more generically a wallet management system and this reference application is a powerful tool to support that. 

In 2025, we will also focus on enabling real-world merchant flows based on requirements from in-country users using the wallets for consumer to merachnt transactions.

Description

The initial mobile wallet framework along with 2 reference apps, PixieCollect and MifosPay, were developed in 2017. Later we decided to continue with MifosPay application only which as mentioned uses the mobile wallet framework.

In 2019, these functionalities were extended further by Shivansh including improving user experience and redesigning the app, support for Kotlin, integration with two Mojaloop transaction flows via the Paymeht Hub, adding improving Deeplinks, support for standing instructions and more well-rounded support for merchant transactions.

In 2020, Devansh Aggarwal further added complete support for standing instructions, integrated with Fineract CN for core use cases by mapping Fineract back-office APIs to Fineract CN APIs, added multi-theme support, completed integration with Payment Hub EE, added support for Hover, and converted Java code to Kotlin (in progress). For more details refer this

In 2021, Kinar Sharma, worked on developing a new multiplatform mobile wallet application using Kotlin multi-platform. This new application consumes FineractCN APIs and is built upon clean architecture. Kinar completed the data, domain and presentation layer (only for Android) for usecases available in FineractCN.

In 2022, Prashant Singh continued to evolve the app.

In 2023, Rachit focused on refining the architecture, streamlining the design and implementing some of the G2P use cases.

In 2024, Pratyush focused on migrating codebase from single module app into kotlin multi-module application by migrating xml to jetpack compose.

In 2025, we are targeting to make production-ready our cases for G2P, update dependencies, consume more uniformly our SDKs fix pending issues and introduce new features. Functional enhancements include:

• Integrate latest version of Payment Hub EE

• Integrate Mifos' notifications framework to provide support for usecases like merchant request to pay.

• Implemented Apple Store and Desktop apps release github action pipeline

• Update wallet framework to be make use of Mifos' Android SDK

• Improving the security framework to integrate more seamlessly with middlewares, API gateway, and identity management software

• Exploring proof of concept architecture or redesigns to align with movements like the Open Wallet Foundation.

• Write end to end Unit and Instrumentation test suite.

Helpful Skills

Android, Kotlin, Kotlin Multiplatform, Jetpack compose, Ktor, Room, Git

Impact

By providing an extensible mobile wallet framework, allow partners a complete reference stack of back and front-end applications to offer digital financial services to clients.

Other Resources

2024 Mobile Wallet Final Report (Pratyush Singh): https://gist.github.com/PratyushSingh07/6509549e64dbee0d695b98c6657a17b2 | Aditya Kumdale: https://gist.github.com/AdityaKumdale/83324009b2e676f8fbc623df4f953497

2023 Mobile Wallet Final Report: https://docs.google.com/document/d/1xHDVzmxuBj5KA0vHiJS_UGrs0Zb6IrpqwRmSdW3uExM/edit#heading=h.h4y8eq18ezr9

2020 Mobile Wallet Progress: https://gist.github.com/devansh-299/e2041c07d9ab55a747391951e9090df4

Mobile Wallet Framework: Source Code | Issue Tracker  | Slack

See https://openmf.github.io/mobile-wallet/

Mentors

Aleksandar Vidakovic Victor Romero

Length

Large - 350 hours

Category

Back-end Platform | Modules

Overview & Objectives

Users of Mifos have long had a need to have greater control and flexibility over creating loan and customer onboarding workflows that incorporate internal processes/steps as well processes involving external systems. This project would center around creating an external integration with a workflow engine such as Flowable or jBPM using the Mifos X REST API as the glue. The auto-generated client library from the back-end enforces the contract between the workflow engine and core banking system. The core banking and its REST API act as the glue. The result would be a UI-driven workflow engine to allow non-technical users to define these new custom workflows where they could drag and drop the different steps of the process. 

Description

Assumptions:

• BPMN should be adopted as a standard so which can make the workflow engine independent of the technology stack. 

• BPMN editors allow end users to sketch the workflow and generate a machine readable and executable output. 

• Workflow actions or business logic would be written in Java as part of Fineract so adapters will be need to be created on the workflow engine to execute actions on our side. 

• External processes would be sub-flows that could be used like lego bricks and included in the parent workflow context. 

Steps:

• Intern would select a workflow engine to integrate with and then build adapters to trigger and transfer fm BPMN form data into specific core banking back-office REST API calls. 

• Currently business logic such as creating a customer is triggered by an API call in Fineract. For this project, the intern would define a BPMN form with all the data that is needed which could be defined as a human task. Proceeding through each step triggers an adapter that transforms the generic BPMN form data into specific core banking back-office REST API calls

• Intern would go through the entire REST API building these adapters to trigger transformation of BPMN into core banking back-office REST API callsCurrently when creating a customer, API by API, the intern would define 

• Once all the calls in Mifos X have been transformed, the integration could provide for triggering any external  customer-specific action/workflow/API call/ system integration

Helpful Skills

Java, BPMN

Impact

UI-Driven interface based on BPMN standard to allow for non-technical users to define customer onboarding and application workflows via a drag and drop interface.

Other Resources

https://github.com/flowable

https://www.jbpm.org/

https://www.bpmn.org/

https://openfn.org

https://n8n.io

Mentors

Aleksandar Vidakovic

Length

Large - 350 hours

Category

Front-End - Web

Overview & Objectives

This project would extend up on existing efforts to create a micro front-end approach for our UIs. As the userbase for Mifos/Fineract extends beyond just microfinance and financial inclusion we need to enable developers to easily build front-end user experiences that align with the wide variety of back-end use cases supported by our platform being used by MFIs, credit unions, banks, fintechs and governments. Additionally, many of the flow and screens used by staff as well as customers are common across mobile and web application.

Right now the look and feel and the overal UI development experience is very limited by using Angular and Material Design.

Description

This project would aim to build both the micro front-end framework and leverage a set of res-usable UI components that can be deployed as individual flows or end to end applications. Growing in popularity for its flexibility, ease of development, efficient performance, modular design is the ShadCN UI Library which contains unstyle components offering a higher degree of customizability.

The current standard UI for Mifos X is still the Web App which is the only one that covers 100% of the feature set. While based on Angular and more modern than our previous Community App, the project hard to maintain and - apart from the occasional color change - hard to customize let alone integrate in other web applications. Developers should be able to pick any number of standalone components and integrate them in custom UI projects (where Fineract is one among multiple backends). All Mifos X UI components should be published for easy consumption by other developers.

Intern would aim to replicate the current Web UI which is in Angular using the Material Design library using ShadCN components built on ReactJS.

This project would use the official typescript API client for Fineract.

Tooling should help with consistency and reduce handwritten code as much as possible. Using Monorepos is strongly suggested.

Helpful Skills

JavaScript, JSX , React, Tailwind CSS

Impact

Developers can more rapidly build out user interfaces for different financial service use cases with a greater degree of design flexibility in terms of customizability of the look and feel

Other Resources

• https://ui.shadcn.com/

• https://peerlist.io/blog/engineering/what-is-shadcn-and-why-you-should-use-it

• https://tailwindcss.com/

• https://www.radix-ui.com/

Mentors

Chinmay Kulkarni Devansh Aggarwal raul.sibaja

Length

Large - 350 hours

Category

Mobile - Mifos X | Core Development | Infrastructure

Overview & Objectives

For 2025, our efforts this project will focus on delivering components that can be utilized as part of Compose Multiplatform and in conjunction with resuable components like ShadCN.

In 2022, Rahul Gill, created and completed the first iteration of our UI library for our mobile apps. Our suite of customer-facing mobile applications include our mobile wallet framework, and mobile banking apps for Fineract 1.x and Fineract CN. These are designed to serve as reference implementations for demonstration purposes but also to act as secure and robust starting dough that can be extended and enhanced and white-labeled.

With the move towards more digital financial services, these reference solutions are ever more important and critical and must appear highly polished, clean, and professional. We are working with a designer to provide a set of clean, consistent and professional UI designs and workflows to implement across our customer-facing apps.

This project would focus on implementing these new designs across the customer-facing apps providing a consistent and familiar look and feel. It will build off of efforts in 2020 and 2021 implementing the UI designs previously proposed during GCI. 

Across all our mobile apps, there are common screens and workflows with a lot of redundant and inconsistent design and development from scratch. The creation of a UI library of common shared components and design standards and guidelines would enable the following:

• Improve developer experience and ease of development

• Consistent look and feel of UIs for all apps

• Defined process for updating apps.

• Develop common UI library to ensure consistency of all apps

• Design guidelines, principles, and standards

• Could potentially be a valuable upstream project in and of itself to create mobile fintech apps

Description

In 2025, with leadership of our mentors, this project would focus on extening the initial shared components of the UI library based off of the common screens and workflows identified across the various mobile apps. These common flows will be broken down into their-base-level elements and components. This components should be built to be compatible with Compose Multiplatform for re-usability across mobile, web, and desktop.

Design enhancements to customer-facing apps include: 

• Break down common workflows into base-level components

• Refine and update design standards and guidelines

• Create and set up repository to house elements, components, and designs using jetpack compose.

• Design core ui component for our fintech app using jetpack compose.

• Develop and create base-level elements and components accoring to UI design standards and guidelines

• Implement screens and workflows to test out on reference open banking fintech app

• Documentation to ensure how to use UI library and update mobile app when UI library is updated.

Helpful Skills

Android Development, Kotlin, Java, Jetpack Compose, XML, Git, Compose Multiplatform

Impact

A clean and simple UI is key for our low-tech audience and professional and consistent look and feel enhances credibility of our stack. 

Other Resources

Recap on 2022 GSOC Project from Rahul Gill: https://gist.github.com/rahul-gill/6700c366627a2c7007a07b96ff6c0785

Mobile App UI Library

2020 UI Enhancements: https://gist.github.com/ShivangiSingh17/67b6041387c1e281caa7df23347f549e

Mobile Wallet Framework: Source Code | Issue Tracker | Slack

Mifos Mobile - Android Mobile Banking App: Source Code | Issue Tracker | Gitter Chatroom

See https://openmf.github.io/mobileapps.github.io/

Mentors

David Higgins + TBC

Length

Large - 350 hours

Category

Platform | DevOps | Mifos Gazelle

Overview & Objectives

Mifos Gazelle brings together multiple components and DPG’s into a single deployment process. A key objective for Gazelle is ease of deployment and ease of use. To that end Mifos Gazelle needs to maintain good documentation and Postman collections of all its API’s (including those of components).

Description

This project would focus on gathering together all the API’s within Gazelle components into a single Postman collection.

Mifos Gazelle users and PHEE, MifosX and vNext users and learners would benefit greatly from a targeted and well tested postman collection and associated environment. This would draw heavily from the existing postman tests for MifosX PaymentHub and vNext perhaps a subset from each and would be specifically customised and organised for a Mifos gazelle deployment of all 3 initial components. This collection would be included in the Mifos Gazelle repository and would also be well documented perhaps with a step by step guide for a number of test scenarios (Mifos Partylookup, vNext PartyLookuop, Bulk Payment etc )

The collection could be very specific for instance hostnames could be set in the environment which are aligned with the Mifos gazelle deployment scripts and well known data (tenants, parties etc) would be utilised.

The folder structure of the collection would also be customised to reflect the Mifos Gazelle deployment

The design needs to be extendable beyond the initial 3 components as Mifos Gazelle grows.

Helpful Skills

Docker, Kubernetes, Jenkins, Bash, REST APIs , Postman.

Impact

DevOps and Sys Admins running our projects would experience a more simplified deployment with greater degree of control, improved quality of their builds and greater reliability and ease of testing through a qualified and reliable Postman collection

Other Resources

GAZ-13 - Getting issue details... STATUS

Mentors

Lalit Mohan S Akshat sharma

Length

Large - 350 hours

Category

AI | Platform - Modules | Exploratory

Overview & Objectives

The "Voice-Driven Banking via Large Acoustic Models (LAMs)" project develops a voice-based banking platform to enable financial transactions in low-resource languages and dialects. The system will support tasks like balance inquiries, fund transfers, credit applications, and more using voice commands, removing barriers of literacy and technical skills. This initiative targets rural and underserved populations, promoting financial inclusion through innovative AI solutions.

Objectives
Technical: Build and deploy LAMs for regional languages and accents, integrated with NLP for intent recognition and voice biometrics for secure authentication.
Business: Expand access to banking services, improve customer engagement, and reduce service costs via automation.
Social: Empower non-literate users in underserved areas with seamless access to financial tools.
Impact and Outcome
Impact
Technical: Robust voice recognition for low-resource languages, secure voice authentication, and modular scalability for future enhancements.
Business: Increased customer base, lower operational costs, and improved satisfaction.
Social: Enhanced financial access for marginalized groups and improved digital literacy.
Outcome
Application: Mobile/web app supporting voice-driven banking in multiple regional languages.
Capabilities: Voice-initiated transactions (balance checks, payments, loans) with real-time processing.
Security: Voice biometrics and encrypted transactions for data integrity.
Analytics: Dashboards to monitor usage and improve language support.
The final product will simplify banking for rural users, bridging the digital divide and boosting financial inclusion effectively.

The idea behind this project is to use a LLM to give command/prompts and have those commands fulfilled via selenium

Description

The "Voice-Driven Banking via LAMs" project focuses on creating a voice-based banking platform supporting low-resource languages and dialects. The intern will:

• Research: Identify target languages and user needs for voice-based banking tasks.

• Develop Core Features:

  • Train/optimize Large Acoustic Models (LAMs) for voice recognition.

  • Build NLP pipelines for multilingual intent recognition.

  • Integrate voice biometrics for secure authentication.

• System Integration: Design a scalable backend and integrate workflows (e.g., balance checks, payments) with banking systems.
  Testing & Optimization: Conduct accuracy and reliability testing, refine models, and ensure accessibility on low-end devices.
  Documentation: Deliver technical documentation, user guides, and training materials in target languages.

• Expected Deliverables

  • A functional voice-based banking app supporting multiple languages.

    • Secure voice-enabled workflows for key banking operations

  • Documentation and guides for system use and maintenance.
    

Helpful Skills

Python, TensorFlow, PyTorch, Natural Language Processing (NLP), Large Acoustic Models (LAMs), speech-to-text systems, voice biometrics, API development

Impact

This project will have a significant impact by promoting financial inclusion, especially for underserved and rural populations. By enabling voice-driven banking in multiple low-resource languages, it empowers individuals who may be illiterate or lack digital skills to manage their finances independently. From a business perspective, it opens new customer segments, reduces operational costs through automation, and drives customer loyalty. Technically, the project advances voice recognition, natural language processing, and secure authentication systems, pushing the boundaries of AI in financial services. Ultimately, this initiative fosters social equality, digital literacy, and economic stability, while innovating how banking can be made accessible to all.

Other Resources

Documentation on Speech-to-Text and Voice Recognition

• DeepSpeech GitHub(https://github.com/mozilla/DeepSpeech ) – Mozilla’s speech-to-text model that may be useful for voice recognition tasks.
  Kaldi(http://kaldi-asr.org/ ) – An open-source toolkit for speech recognition, widely used in research.
  Large Acoustic Models (LAMs) and NLP Resources

• Speech Recognition with Deep Learning – A tutorial on speech recognition using TensorFlow.
  Transformers by Hugging Face – A popular NLP library that could be adapted for multilingual NLP tasks.
  Voice Biometrics and Security

• Voice Authentication System (API) – Twilio API for implementing voice biometrics in applications.
  General AI and Machine Learning for Banking

• AI in Financial Services – An article detailing AI applications in the financial sector.
  Financial Services AI – A report from Accenture on the future of AI in banking.

Mentors

jeremy engelbrecht

Length

Large - 350 hours

Category

AI | Platform - Modules | Exploratory

Overview & Objectives

The idea behind this project is to use a LLM to give command/prompts and have those commands fulfilled via selenium

Description

Following the similar types of commands/actions that can be executed in Fineract via our chatbot, this project would use LLMs to determine the intent of a user and fulfill those actions in the Mifos/Fineract applications using a tool like Selenium.

Helpful Skills

Python, LLM(Llama2 or similar), Selenium

Impact

This would dramatically change the way individuals interact with financial services. It goes well beyond a chatbot by being able to engage with a tool that can apply for and initiate financial transactions via prompts.

Other Resources

https://xgboost.readthedocs.io/en/stable/

Mentors

jeremy engelbrecht Lalit Mohan S David Higgins

Length

Large - 350 hours

Category

AI | Platform - Modules | Exploratory

Overview & Objectives

Mifos & Apache Fineract provide a suite of core banking applications which are highly complex applications both from a technical and domain knowledge perspective. 

Maintaining updated documentation around installing, configuring and using the application is challenging and presents a steep learning curve.

The goal of this project is to use Generative Pretrained Transformer (GPTs) (which is a family of large language models (LLMs) based on a transformer deep learning architecture) for providing answers  to most common questions and for organizing documentation. It is important to ingest data for training this GPT using the manuals, source code repositories, Wiki, ReadMes, mailing list posts, forum posts, slack discussion, and documentation hosted on our project sites, it would greatly simplify the experience for any implementer looking to use the software.

Description

In 2025 the Intern would develop/train a GPT using all the sources of technical and user documentation across our project such that implementers could interact with the documentation in a Q&A style format.

In 2024 in an initial increment of this project an LLM was created that was trained on a specific subset of documentation.

In 2025 focus needs to be on how this can be scaled across the full documentation set, how to resolve conflicts in answers when you look at large scale documentation.  

AI tools have changed significantly in the last year that the approach should be changed so then the interaction with them can be implemented using agents.

An alternative focus of this project could be how to use AI to generate or update documentation at the point of release.

Helpful Skills

Hugging Face, LlaMA, Colab, GPT, N8N.

Impact

This would greatly simplify the process of configuring, deploying and using our core banking software across various use cases making the software and documentation more maintainable for the project and more usable for the customer base.

Other Resources

https://www.ibm.com/think/topics/generative-ai

https://www.ibm.com/think/topics/transformer-model

https://www.synechron.com/insight/generative-ai-answering-your-frequently-asked-questions

https://huggingface.co/docs/transformers/model_doc/llama2

https://youtu.be/FuLY96AKWjc?feature=shared

Mentors

jeremy engelbrecht Lalit Mohan S Aleksandar Vidakovic

Length

Large - 350 hours

Category

AI | Platform - Modules | Exploratory

Overview & Objectives

With continually growing adoption of Payment Hub EE to connect fiancial institutions using or not using Fineract into real-time payment systems, the likelihood of fraud is ever-growing. With all of this transactional data flowing into and out of Fineract, there is now also a wealth of data to analyze using rule-based and AI-based methods to detect transactional patterns and identify fraud. A lot of fraud detection and transaction monitoring happens centrally at the level of the payment switch but there’s quite a bit of value in analyzing this at the level of each individual DFSP and sharing this on-us transaction data back to the central payment switch or system

Goal of this project would be to work on a proof of concept integration between Mifos/Fineract and Payment Hub EE with a FRMS solution for fraud detection and transaction monitoring. Given the power and potential of generative AI for financial services, project shoudl explore the use of generative AI for the following areas as documented by Newron:

• Anomaly Detection: Generative AI models can create synthetic data that mimics legitimate transactions. By training on both genuine and synthetic data, models become adept at detecting unusual patterns indicative of fraud.

• Adaptability: Unlike rule-based systems, Generative AI models can adapt to new fraud patterns. As fraudsters evolve, the model evolves with them, improving detection rates.

• Data Augmentation: Generative AI can augment imbalanced datasets by creating synthetic examples of rare events (fraudulent transactions), making the model more robust.

• Unsupervised Learning: Generative AI models, like Variational Autoencoders (VAEs) or Generative Adversarial Networks (GANs), learn patterns in an unsupervised manner, reducing the need for manual labeling of fraudulent cases.

• Behavioural Analysis: Generative AI can analyze transaction behaviours, such as user interactions or purchasing habits, to identify deviations from the norm

Project could be integrated with Tazama which although rule-based and not AI-based provides a powerful FRMS solution.

Description

Intern would work on a POC integration to monitor and analyze data from real-time payment system flowing via Payment Hub EE into Fineract. Project could utilize generative AI to improve effectiveness of solutiona and can leverage existing efforts in the community to collaborate with eKuta solution.

Helpful Skills

Hugging Face transformer, Llama2 or similar, Colab

Impact

Real-time payments make the challenges and consequences of fraud ever more steep and severe. Using Generative AI to combat it and integrating with FRMS solutions will help the user base using Payment Hub EE and Fineract.

Other Resources

• https://www.linkedin.com/pulse/revolutionising-fraud-detection-generative-ai-newron/

• Open Source Solution FRMS Solution - Tazama - https://tazama.org/

Mentors

Rajan Maurya

Length

Large - 350 hours

Category

Mobile, Kotlin Multiplatform, Compose Multiplatform

Overview & Objectives

Throughout 2024, we continued migrating all of our mobile apps to Kotlin Multiplatform and in the processed developed some valuable generic tools and templates to help with building out applications using Kotlin Multiplatform. This project would continue to refine and extend these frameworks.

Description

The focus for 2025 on this project would be the following:

• Write Material Design3 component layer that can be customizable on top level so anyone forking the repo and creating a project can just add the theme configuration and rest is maintainable in template.

• Write base configuration for Android, Ios, Desktop, Web so whoever is creating project out of template will only adding configuration that will replace the default one.

• Write release github actions for all the platform Android, Ios, Desktop, web using Github Actions.

• Write network, database, datastore etc base layer so it will act like external component can be or can’t be added in the project.

• Write Gradle plugin for dependencies like Room, datastore, ktor, compose etc so it can behave as component and we can have introduce Amper as an alternative for build system.

• Make sync common directories more generic.

Helpful Skills

Android, Kotlin, Kotlin Multiplatform, Jetpack compose, Ktor, Room, Git

Impact

Streamling the developer experience and reducing the learning curve for building cross-platform apps with native user experiences on top of Kotlin Multiplatform.

Other Resources

Source Code

• https://github.com/openMF/kmp-project-template

Mentors

Rajan Maurya

Length

Large - 350 hours

Category

Mobile, Kotlin Multiplatform, Compose Multiplatform

Overview & Objectives

Throughout 2024, we continued migrating all of our mobile apps to Kotlin Multiplatform and in the processed developed some valuable generic tools and templates to help with building out applications using Kotlin Multiplatform. We realized over past experience that we need a Kotlin Multiplatform tool that checks and take care of app health and give out summary of app breaking points and manage whole thing locally and as well as pushes to firebase logging so we can know where exactly the problem lies instead of walking to crash analytics.

Description

The focus for 2025 on this project would be the following:

• Designing a plan and Product specs.

• Write a local database layer that will store all data required to debug the crash, issue etc.

• Write a sync layer for Kotlin Multiplatform that gives ability to pull issues and debug stream data to fix the issue.

• Design a frame work that will take write in firebase events and manage in such a manner so we can find where issue lies.

• Write a layer that will look for memory leak in the code and analyze and suggest fixes using AI

• Give ability user to expose or keep whole thing locally.

• Write logging layer that will be annotation based and log things for debugging.

Helpful Skills

Android, Kotlin, Kotlin Multiplatform, Jetpack compose, Ktor, Room, Git

Impact

Streamling the developer experience and reducing the learning curve for building cross-platform apps with native user experiences on top of Kotlin Multiplatform.

Other Resources

Source Code:

• https://github.com/openMF/app-health-kmp

Mentors

Shashank Priyadarshi

Length

Large - 350 hours

Category

Mobile, Exploratory

Overview & Objectives

The 2025 focus for this project would be extending upon the work that was done during Code for GovTech in 2024. Across our ecosystem we're seeing more and more adoption and innovation from fintechs. A huge democratizing force across the financial services sector is the Open Banking movement providing Open Banking APIs to enable third parties to directly interact with customers of financial institutions. We have recently started providing an Open Banking API layer that will allow financial institutions using Mifos and Fineract to offer third parties access to requesting account information and initiating payments via these APIs. Most recently the Mojaloop community, led by Google, has led the development of a centralized PISP API

To demonstrate these Open Banking APIs and use cases that third parties and fintechs can provide we have developed a cross-platform reference mobile app on Kotlin to showcase a number of these features. It currently connects with the Open Bank Project that adheres to the UK Open Banking API standard. The API Gateway to connect to is still being chosen (WS02, Gravitee, etc.)

The breadth and variety of apps that could be built leveraging these APIs from region to region is endless. We would like this app to be built in an extensible and modular fashion such that core libraries and components could be re-used across different use cases with this framework as the foundation and multiple reference apps on top. Applications include personal financial management apps aggregating information from multiple bank accounts in one place, wallet apps allowing payments to be made from different banks, lending apps, leveraging data and insight from multiple accounts, savings apps, etc.

Description

Intern would work on refining the initial architecture of the framework, the UI and user experience, core use cases including customer authentication and onboarding that was implemented in 2020 and integrating with the Fineract Open Banking APIs and Mojaloop PISP APIs to demonstrate use cases around account information request and payment initiation. 

This would be a continuation of the project worked on a couple year’s back but essentially the idea is the same to have a stand-alone reference third party fintech app that demonstrates 3rd party initiation/ Open Banking APIs so the app itself would need its own separate user managment, etc but then it would pull in data by authorizing consnet via open banking api to pull in transactional data from a mifos/fineract account (could extend exiting open banking adapter and map additional fineract apis to UK open banking api standard and most importantly we’d want to use this reference fintech app to demonstrate the use of Mojaloop/Google 3PPI PISP APIs whereby a user could authorize and establish consent across any bank participating in a mojaloop switch to the fintech to initiate transactions through mojaloop via their accounts managed in Mifos/Fineract

• Aggregating account information across multiple banks/financial institution

• Initiating payments across multiple financial institutions

• Integrate with additional Fineract Open Banking APIs

• Integrate with Mojaloop PISP APIs. 

• Leverage completed components of UI library

Helpful Skills

Android development, SQL, Java, Javascript, Git, Spring, OpenJPA, Rest, Kotlin, Mojaloop

Impact

By providing an extensible open banking fintech app framework, allow partners a complete stack of Open Banking APIs and reference front-end application to rapidly build innovation via Open Banking APIs.   

Other Resources

Source code: https://github.com/openMF/pisp-app

Figma Design Mockups: https://www.figma.com/proto/ZkQJHzXWfjZugpTtz1MFdt/Mifos-PISP-App?node-id=10-27&starting-point-node-id=101%3A32&scaling=scale-down&t=vtBsVklbforA4MiB-1

Previous Development:

• 2023 Mifos Summer of Code Final Report - https://gist.github.com/lssarao/fc1293ad3c36d51317358348323b80c0

• 2020 Google Summer of Code Final Report - https://gist.github.com/ankurs287/4ef7c3de462073bf36bd5247479cb176

Google Whitepaper on 3PPI: https://static.googleusercontent.com/media/nextbillionusers.google/en//tools/3PPI-2021-whitepaper.pdf

UK Open Banking API Standard: https://standards.openbanking.org.uk/

Open Banking Developer Zone: https://openbanking.atlassian.net/wiki/spaces/DZ/overview

Examples of Open Banking Apps: https://www.ft.com/content/a5f0af78-133e-11e9-a581-4ff78404524e

See https://openmf.github.io/mobileapps.github.io/

Mentors

 Jose Hernandez Aleksandar Vidakovic Ed Cable

Category

Web - Mifos X Web App/Fineract

Overview & Objectives

Originally this idea was sparked by looking at what Moov has around UI drops - https://moov.io/product/drops/ and https://docs.moov.io/moovjs/drops/ Many different goals, directions, use cases emerge but they would all share in helping make UI more maintainable, more pluggable and having more of a toolkit for builders/developers that would align with Fineract being used for various core banking use cases outside of just financial inclusion as well as the need supporting a variety of fintech use cases with common elementsIn conversation with others, some different directions could emerge:

• @Nayan Ambali and seeing how Finflux has separated out UIs for different personas

• With @Victor Romero  serving the need to help others do custom/specific page view for certain functionality

• Ability to more pluggable components especially for customer-facing operations/use cases

• Have micro-front-ends be brought together to create a monolithic application like the web-app

• @aleksvidakovic suggestion on the real value being in how these components are used in other frameworks/portals and not a full complete application like we currently have.

For this round of GSOC I’d like us to define a project where we could do a micro front-end around a certain domain/functionality and pick a framework/design/architectural approach that we’d follow. (edited) 

Our 2022 intern, Ramveer Singh made substantial progress in completing the development of our new web app such that the Web App is now part of the Mifos X release distribution and we’ve fully deprecated our older Community App. Our Angular Web App is the standard application on the Mifos X distribution that provides all the core functionality for the most common methods of financial inclusion and products and services. It's also the starting point for any partners looking to customize or extend the UI. It's constantly being improved based on user feedback, better performance, and to integrate new design standards.

The focus for 2025 will be on continuing to optimize the design of key flows, improving app localization, adding in better context-sensitive help, improving dashboards and visualizations, and refactoring of the web app to consume a type-script client for better maintainability.

Description

Given this project is in it infancy, this would really be a proof of concept design the proper archiecture, learn which use cases are best candidates for pluggable and modular UI components and then choosing a framework in which to deploy multiple micro front-end as a single applicaiton with a unified user experience for end users.

• Propse and design architecture for Micro Front End approach

• Determine best front-end language or javascript framewor to use - leaning towards Angular

• Identify which existing screens or new screens should be implemented as seaprate microservice UIs.

Primary efforts center around:

• Fixing remaining issues

• Redesigning customer and account dashboard pages

• Refactor web app to consume typescript client

• Enhance look and feel of app.

• Implement third party library for proper internationalization.

The remaining issues can be found: https://github.com/openMF/web-app/issues

The progress is being tracked here: https://docs.google.com/spreadsheets/d/1JxeJjG1GdZ3BNJi-sScCQLirfevSc8amFr8o3SfUj4U/edit?usp=sharing

Some additional work also includes adding in comprehensive keyboard shortcuts to enable power-users of the app and to ensure that the tabs and arrow keys work appropriately for navigating through the app, localization support, additional dashboards, adding of tooltips, etc. 

Helpful Skills

Javascript, SCSS, HTML5, Angular 9, Angular Material, Flex Layout

Impact

More pluggable, faster to develop, modular UI that better supports variety of use cases of Fineract.

• Reduced dependency on using entire monolithic app.

Other Resources

Usability and Design

Moov UI Drops - https://moov.io/product/drops/ and https://docs.moov.io/moovjs/drops/

Article on Angular & Micro Front-ends using Module Federation - https://auth0.com/blog/micro-frontends-with-angular-module-federation-and-auth0/

Mentors

  Bharath Gowda Pushpendra Kumar Ramveer

Category

Web - Mifos X Web App

Overview & Objectives

Our Angular Web App is the standard application on the Mifos X distribution that provides all the core functionality for the most common methods of financial inclusion and products and services. It's also the starting point for any partners looking to customize or extend the UI. It's constantly being improved based on user feedback, better performance, and to integrate new design standards. Our 2024 interns, Omar Nabil, progress our implementation of translations, redefined styling in the app and implemented a number of usability improvements. This built upon the work of our 2023 intern, Pushpendra who completed the remaining work on the web app to fully deprecate our Community App.

2025 focus will be on continuing to optimize the design of key flows, continued improvements to app localization, adding in better context-sensitive help, improving dashboards and visualizations, and completing the refactoring of the web app to consume a type-script client for better maintainability.

Description

Our legacy community app is now fully deprecated so we must continue to refine the Mifos X web app including updating core dependencies. We must upgrade Angular to its latest stable verison and implement a number of critical design and usability enhancements to the core customer account and dashboard pages. In order to synchronize the UI with the version of each release of the back-end platform we need to complete the refactoring of the interaction layer to consume the auto-generated typescript client, and deepend the integration and seamless user experience with Apache Superset for dashboards and visualizations.

Primary efforts center around:

• Update Angular to latest stable version

• Fix identified usability improvements prioritized by community

• Redesign customer and account dashboard pages

• Implement UI screens for new features contributed by commumity

• Implement authentication framework to fully integrate Superset for dashboards.

• Finalize refactoring of web app to consume typescript client

• Enhance look and feel of app.

• Continued Improvements of translations

Usability Issues and Improvements can be found: https://mifosforge.jira.com/jira/software/c/projects/WEB/boards/62

Some additional work also includes adding in comprehensive keyboard shortcuts to enable power-users of the app and to ensure that the tabs and arrow keys work appropriately for navigating through the app, localization support, additional dashboards, adding of tooltips, etc. 

Helpful Skills

Javascript, SCSS, HTML5, Angular, Angular Material, Flex Layout

Impact

Enhanced User Experience, Intuitive application design

Other Resources

2024 Progress (Omar): https://gist.github.com/Omar-Nabil/29c15796df1abcba7f3bb85f344d2e8a

2023 Progress: https://gist.github.com/PC-11-00/8f726c2a6719c7493accbaa58bcfb047

2022 Progress: https://gist.github.com/ramvr1256/11c197b038250e7394462e8687ef15f8

2020 Progress: https://gist.github.com/karantakalkar/7a4acb83f31ebfe4f3b827c86c67eec0

https://gist.github.com/muskankhedia/b0929cbf2ae6236bfe07964a140da179 Usability and Design

Mentors

David Higgins +TBC

Length

Large

Category

Platform - DevOps | Infrastructure

Overview & Objectives

Over the past 2 years we have developed a Deployment Tool for DPI infrastructure called Mifos Gazelle. This aligns to DPI as a packaged Solution (DaaS) toolkit approach. It currently (as of v1.0.0) deploys 3 DPG components a Payment Orchestration (Mifos Payment Hub EE) a core banking solution (Mifos X including Fineract as a backend) and a payment switch (vNext Beta 1.0). There is a roadmap to include other DPGs and by the start of this project there may be a 4th DPG included.

Description

Currently the Mifos Gazelle deployment does not have an easy way to create demos or profiles although there has been alot of thought and discussion around this see GAZ-17 - Getting issue details... STATUS .

This project would look into this area research the options, agree the approach with the mentors and community and develop the first profile/demo creator tool for Mifos Gazelle.

This project would suit someone who wants to explore and define a new element to a project rather than just follow a set of tasks.

Helpful Skills

Docker, Kubernetes, Jenkins, Bash, Java - Spring, PostgreSQL, MariaDB, Cassandra, TDD With JUnit 4, Gradle, CircleCI, Helm, UI , Angular, Research + other soft skills

Impact

Provide an easy way for institutions considering DPI to deploy and develop use cases and demos on Mifos Gazelle.

Other Resources

Helm Chart for Fineract deployment - https://github.com/fynarfin/fineract-env/tree/master/helm/fineract

Helm Charts for Payment Hub EE deployment  - https://github.com/openMF/ph-ee-env-labs/tree/master/helm

Docker Compose for Mifos - (Fineract Back-End + Web App) - https://github.com/openMF/mifos-x-containers

Docker Hub Image of Fineract - https://hub.docker.com/u/openmf

https://hub.docker.com/r/apache/fineract

Fineract Technical Documentation - https://fineract.apache.org/docs/current/

Miniloop -  https://github.com/tdaly61/mini-loop.git

Payment Hub EE - https://payments.mifos.org

Lab Environment Overview - https://mifos.gitbook.io/docs/payment-hub-ee/overview/lab-environment

GAZ-17 - Getting issue details... STATUS

Mentors

tom daly

Length

Large

Category

Platform - DevOps | Infrastructure

Overview & Objectives

Over the past 2 years we have developed a Deployment Tool for DPI infrastructure called Mifos Gazelle. This aligns to DPI as a packaged Solution (DaaS) toolkit approach. It currently (as of v1.0.0) deploys 3 DPG components a Payment Orchestration (Mifos Payment Hub EE) a core banking solution (Mifos X including Fineract as a backend) and a payment switch (vNext Beta 1.0). There is a roadmap to include other DPGs and by the start of this project their may be a 4th DPG included.

Description

Currently the Mifos Gazelle deployment does not support ARM although the vNext already runs and builds docker images for ARM. This project would primarily focus on updating all the OpenMF pipelines for MifosX and Payment Hub EE such that it can be built for ARM. This may included the 4th DPG at that point.

This would allow for running on Apple devices or Raspberry Pi.

We would like to be able to run Mifos Gazelle on a couple of Raspberry Pi devices (we call this DPI in a Box). This project could extend to include this depending on time.

The Intern must be able to problem solve. We expect during this exercise to hit challenges especially around dependencies that will need to be resolved (especially for Payment Hub EE) and this may result in upstream contributions to these DPGs.

Helpful Skills

Docker, Kubernetes, Jenkins, Bash, Java - Spring, PostgreSQL, MariaDB, Cassandra, TDD With JUnit 4, Gradle, CircleCI, Helm

Impact

Provide an easy to deploy package to help institutions considering DPI to deploy and develop use cases.

Other Resources

Helm Chart for Fineract deployment - https://github.com/fynarfin/fineract-env/tree/master/helm/fineract

Helm Charts for Payment Hub EE deployment  - https://github.com/openMF/ph-ee-env-labs/tree/master/helm

Docker Compose for Mifos - (Fineract Back-End + Web App) - https://github.com/openMF/mifos-x-containers

Docker Hub Image of Fineract - https://hub.docker.com/u/openmf

https://hub.docker.com/r/apache/fineract

Fineract Technical Documentation - https://fineract.apache.org/docs/current/

Miniloop -  https://github.com/tdaly61/mini-loop.git

Payment Hub EE - https://payments.mifos.org

Lab Environment Overview - https://mifos.gitbook.io/docs/payment-hub-ee/overview/lab-environment

GAZ-10 - Getting issue details... STATUS

Mentors

Victor Romero Avinash Vijayvargiya

Length

Large - 350 hours

Category

Mobile/Platform

Overview & Objectives

A powerful and compelling use case of Mifos X is to power any type of customer-facing digital experience (mobile wallet, mobile banking, etc). However we must enable these digital experiences to connect securely to the back-end. We currently have a self-service API layer which is valuable for demonstrating customer-facing actions that can be performed via mobile banking and online banking apps but these APIs were not intended for deployment in live production environment and are being deprecated for a more secure option.

This project would focus on building out the self-service middleware SDK for Mifos X and Apache Fineract by defining a subset of the APIs to secure expose such that external users can inititate transactions and interact with accounts within Fineract.

Victor Romero has created a design for implementation of this middleware layer and would mentoring the intern to implement this design.

Some of these effort will also align with previous efforts around Open Banking APIs. Across our ecosystem we're seeing more and more adoption and innovation from fintechs. A huge democratizing force across the financial services sector is the Open Banking movement providing Open Banking APIs to enable third parties to directly interact with customers of financial institutions. We have started providing an Open Banking API layer that will allow financial institutions using Mifos X to offer third parties access to requesting account information and initiating payments via these APIs. This also aligsn with the centralized PISP API introduced within Mojaloop by Google.

Tremendous impact can be had at the Base of the Pyramid by enabling third parties to establish consent with customers authorize transactions to be initiated or information to be accessed from accounts at their financial institution. This  Open Banking API layer would enable any instituion using Mifos or Fineract to provide a UK Open Banking API layer  to third parties and fintechs.  

 The API Gateway to connect to is still being chosen (WS02, Gravitee, etc.)

Description

In 2025, Intern would need to familiarize with the proposed design and initial codebase contributed by Victor. This design follows the existing architectural patterns of our SDKs and client, exposin the appropriate APIs using coroutines and publishes them in a secure manner. The APIs that are consumed by the mobile banking applications have been documented in the spreadsheet below. The APIs have also been categorized according to whether they are an existing self-service API or back-office API and if they have an equivalent Open Banking API and if so, a link to the corresponding Open Banking API.

For example: 

• Submit Loan Application (Self-ServiceAPIwith EquivalentOpenBankingAPI)

  • https://demo.mifos.io/api-docs/apiLive.htm#loans_create Used by Mifos Mobile

• ImagesAPI(Back-OfficeAPIwith No EquivalentOpenBankingAPI)

  • https://demo.mifos.io/api-docs/apiLive.htm#client_images Used by Mifos Mobile and Mobile Wallet 

• Fetch Identification CardAPI(Fineract CNAPIwith no equivalentOpenBankingAPI)

  • https://docs.google.com/document/d/15LbxVoQQRoa4uU7QiV7FpJFVjkyyNb9_HJwFvS47O4I/edit?pli=1#heading=h.xfl6jxdpcpy1

Sample APIs to be Documented

-------------------------------------------

Mifos Mobile API Matrix (completed by Ashwin)

https://docs.google.com/spreadsheets/d/1gR84jZzLF-mM0iRw5JyeMAsHMK6RQPK0vyDmNAY9VhE/edit#gid=0

MIfos Mobile API Matrix (completed by Shivangi)

https://docs.google.com/spreadsheets/d/1exTv68v1IW_ygS7mSj0_ySFWGTj06NcxPZeNLjNIy6Y/edit?pli=1#gid=0

Helpful Skills

Android development, SQL, Java, Javascript, Git, Spring, OpenJPA, Rest, Kotlin, Gravitee, WSO2

Impact

By providing a secure middleware layer we can enable both trusted first party apps to allow customers to autheniticate and access their accounts as well as an API layer for third party fintechs to securely access FIneract and request information or initiate transactions with the consent of customers.

Other Resources

Self-Service Middleware Layer/Plugin (Designed Implemented by Victor): https://github.com/openMF/selfservice-plugin

CGAP Research on Open Banking: https://www.cgap.org/research/publication/open-banking-how-design-financial-inclusion

Docs: https://mifos.gitbook.io/docs/wso2-1/setup-openbanking-apis

Self-Service APIs: https://demo.mifos.io/api-docs/apiLive.htm#selfbasicauth

• https://cwiki.apache.org/confluence/display/FINERACT/Customer+Self-Service+Phase+2

Open Banking Adapter: https://github.com/openMF/openbanking-adapte

• Transforms Open Banking API to Fineract API | Can connect to different API gateways and can transform against different API standards.

Reference Open Banking Fintech App:

• Backend:https://github.com/openMF/openbanking-tpp-server | GUI: https://github.com/openMF/openbanking-tpp-client

Google Whitepaper on 3PPI: https://static.googleusercontent.com/media/nextbillionusers.google/en//tools/3PPI-2021-whitepaper.pdf

UK Open Banking API Standard: https://standards.openbanking.org.uk/

Open Banking Developer Zone: https://openbanking.atlassian.net/wiki/spaces/DZ/overview

Examples of Open Banking Apps: https://www.ft.com/content/a5f0af78-133e-11e9-a581-4ff78404524e

See https://openmf.github.io/mobileapps.github.io/

Mentors

Ed Cable

Length

Large - 350 hours

Category

Back-end Platform - Modules & Integration (Mifos X)

Overview & Objectives

Provides financial institutions with real-time insights into loan risk, helping them make better lending decisions.
A reactive backend ensures the system can handle a growing number of requests as Mifos deployments expand.
Improved risk assessment can lead to more responsible lending practices, ultimately benefiting underserved communities.

Description

In 2025 the Intern would:

Create a dedicated microservice in Java that handles loan risk assessment asynchronously.
Utilize reactive programming paradigms to ensure scalability and high throughput.

Design and implement a configurable risk scoring model that can incorporate multiple factors such as client financial history, repayment behavior, and external credit ratings.
Allow for model tuning via configuration, so institutions can adapt the scoring criteria to local requirements.

Helpful Skills

Java, Spring Boot, Microservices, Gradle, testing, SQL

Impact

This project will significantly enhance the Mifos X and Apache Fineract platforms by improving the scalability, performance, and reliability of backend services. By transitioning to a reactive microservices architecture using modern Java technologies like Spring

Other Resources

• https://issues.apache.org/jira/browse/FINERACT-2021

• https://issues.apache.org/jira/browse/FINERACT-2022

• http://querydsl.com/

Mentors

Victor Romero

Length

Large - 350 hours

Category

Mobile | Platform - Integrations

Overview & Objectives

As more and more implementers of Mifos X, use the platform for digital and neobank use cases, the ability to remotely capture check (i.e. mobile check deposit) becomes necessary. There are many proprietary solutions to achieve this but this project would aim to create a Proof of Concept that is completely open source to enable a neobank or any financial institution to offer to its members mobile check deposit capability. This would especially be relevant for the credit unions, community banks and smaller financial institutions that are adopting MIfos and Fineract as their core system.

Description

This project would be built as a new module that is easily embedded or integrated into our Mifos Mobile self-service mobile banking app. It would consist of an open source tool for actually scanning or capturing the check deposit and use the Moov open source Image Cash Letter library to parse, create, and validating ICL files.

Image Cash Letter (ICL) specifications provide Check 21 services and are designed to enable banks to handle more checks electronically, which should make check processing faster and more efficient. Traditionally, banks often physically move original paper checks from the bank where the checks are deposited to the bank that pays them. The overall process of translating physical checks to electronic messages is called Check Truncation.

Helpful Skills

Java, Android,Kotlin, Compose, Go

Impact

Ease of use for end user - enabling small financial institutions like credit unions to offer mobile check deposit at lower cost.

Other Resources

• Moov Image Cash Letter Library - https://moov-io.github.io/imagecashletter/

• Demo of ICL Library - https://oss.moov.io/x9/

• Github of ICL Library: https://github.com/moov-io/imagecashletter

• Proprietary Remote Check Capture applications - https://www.prove.com/blog/10-remote-cheque-deposit-applications-in-us-from-non-banks

Mentors

Victor Romero Aleksandar Vidakovic

Length

Large - 350 hours

Category

Platform - Modules

Overview & Objectives

Mifos/Fineract is a very robust and highly functional Loan Management System of Record. Typically adopters of the system will build their own or implement a third party tool to score their borrowers, analyze credit risk, and do their loan decisioning as part of their origination processes. Once this decisioning engine has determined eligbiility of the borrower, the customer and loan and ensuing lifecycle can then be managed in Mifos/Fineract. Mifos/Fineract can easily receive information from this decisioning engine and send information to the decisioning/scoring engine to faciilitate this analysis.

There are a number of different best practice alternative and traditional credit scoring/decisioning tools that Mifos/Fineract could more tightly integrate with. By providing a working integration of plugin framework for integrating with decisioning, our community can have better access to decisioning tools to improve the health of their portfolios. This project would extend up on existing efforts to create a micro front-end approach for our UIs. As the userbase for Mifos/Fineract extends beyond just microfinance and financial inclusion we need to enable developers to easily build front-end user experiences that align with the wide variety of back-end use cases supported by our platform being used by MFIs, credit unions, banks, fintechs and governments. Additionally, many of the flow and screens used by staff as well as customers are common across mobile and web application.

Description

This project endeavors to create a plugin framework for integration with external decisioning engines. It should identify, design, and build out the points of integration and interaction for inbound and outbound data flows at both the back and front-end for decisioning/scoring tools of both traditional as well as alternative sources of data. This work would include leveraging Fineract data tables for storing and displaying this external data, the respective webhooks, APIs, and events that are called or triggered during the scoring process. Likewise this project would dovetail well with our workflow engine integration as flows would be calling both of these systems. Traditional providers we could potentially build integrations with include Lokyata which provides more out of the box scoring or tools like nTropy which allow data enrichment to build ones one model. On the alternative side, we are exploring integration with Begini which provides pyschometric assesment data as well as behavioral and usage data from the phone to assess credit worthiness.

Work would be be on both the back and front-end.

Helpful Skills

Java, Spring, Angular, PostgreSQL, MySQL/MariaDB, REST

Impact

Cost-effective and modern decisioning to improve the health and creditworthineess of a loan portfolio. More replicable integration points with external systemn that can be followed for other integrations.

Other Resources

• https://www.lokyata.com/index.html

• https://www.ntropy.com/

• https://www.begini.co/

Mentors

Pushpendra Kumar b20 122

Length

Large - 350 hours

Category

UI, Mobile

Overview & Objectives

This project would extend up on existing efforts to create a micro front-end approach for our UIs. As the userbase for Mifos/Fineract extends beyond just microfinance and financial inclusion we need to enable developers to easily build front-end user experiences that align with the wide variety of back-end use cases supported by our platform being used by MFIs, credit unions, banks, fintechs and governments. Additionally, many of the flow and screens used by staff as well as customers are common across mobile and web application.

Description

This project would aim build both the micro front-end framework and set of UI components that can be deployed as individual flows or end to end applications across both web and mobile. Recently emerging is the Compose Multiplatform which extends Jetpack Compose to work beyond just mobile devices.

The current standard UI for Mifos X is still the Web App which is the only one that covers 100% of the feature set. While based on Angular and more modern than our previous Community App, the project hard to maintain and - apart from the occasional color change - hard to customize let alone integrate in other web applications. Developers should be able to pick any number of standalone components and integrate them in custom UI projects (where Fineract is one among multiple backends). All Fineract UI components should be published for easy consumption by other developers.

Documentation of the project could follow latest best practices (aka “Storybook”)

Tooling should help with consistency and reduce handwritten code as much as possible. Using Monorepos is strongly suggested.

Helpful Skills

JS, Android, React, CSS

Impact

Developers can more rapidly build out user interfaces for different financial service use cases with a greater degree of design flexibility

Other Resources

• https://www.jetbrains.com/lp/compose-multiplatform/

• https://github.com/JetBrains/compose-multiplatform

Mentors

Ed Cable Manoj VM

Length

Large - 350 hours

Category

Platform & Modules - Digital ID, Exploratory, Bleeding Edge

Overview & Objectives

Digital Identity is a pressing topic and for both generations of Fineract (1.x and CN), we'd like to have integration with emerging KYC and digital identity solutions.

KYC (Know your customer) is a fundamental banking concept. It refers to the process of identifying a new customer at the time of account opening, in compliance with law and regulation. The identification requirements may be lower for low value accounts ("Tiered KYC"). The term is also used in connection with regulatory requirements for a provider to understand, on an ongoing basis, who their customer is and how they are using their account. Most of the banks are mandated to perform basic/extensive KYC, before they can serve their customers.

Traditionally KYC is done in a centralised fashion where a central agency has the control over all the data. For example consider each bank like SBI, Deutsche, JP Morgan, etc. when creating a bank account, each of them requires a separate KYC process to be completed and all this data gets stored in their respective databases. Even the systems like Aadhar or social security number, etc. have the data stored in a central manner and maintained by the government. However, in recent times all these centralised identity servers continue to be hacked and the important and private data being stolen regularly.

Omidyar Network along with Gates Foundation have developed the MOSIP project which provides an open source digital ID platform. Integration between Mifos along with Mojaloop can provide an end to end reference architecture for a digital cash transfer system built on open source digital public goods. 

• Decentralised system means that no one person has control over sensitive data.

• It enables the re-use of KYC, i.e. each financial institution or in our case each customer using Fineract may not have to perform its own complete KYC, but re-use the KYC already performed by others (those who have the power as issuing authority for any kind of claim).

• Cryptographic security is the heart of blockchain technologies enhancing privacy.

• Claim-based system where the end user/customer has the control over his data.

Description

Integration between Mifos and digital identity systems and KYC protocols could be deepened. This project would focus on an initial proof of concept integration with MOSIP APIs for digital identity including

• ID Repository

• ID authentication

• Biometric Integration 

• Registration 

Registering a client with a MOSIP-powered Digital Identity in a Mifos system and verifying that digital identity to perform transactions. 

Helpful Skills

HTML, Spring, Hibernate, REST, Java, AngularJS, Javascript, SQL, 

MOSIP 

Impact

Other Resources

• MOSIP https://www.mosip.io/

• MOSIP Docs: https://docs.mosip.io/platform/

Mentors

Lalit Mohan S  Nasser Kaze Victor Romero

Length

Large - 350 hours

Category

AI, Platform - Modules, Bleeding Edge

Overview & Objectives

Financial Organizations using Mifos/Fineract are depending on external agencies or their past experiences for evaluating credit scoring and identification of potential NPAs. Though information from external agencies is required, financial organizations can have an internal scorecard for evaluating loans so that preventive/proactive actions can be done along with external agencies reports. In industry, organizations are using rule based, Statistical and Machine learning methods for credit scoring, predicting potential NPAs, fraud detection and other activities. This project aims to implement a scorecard based on statistical and ML methods for credit scoring and identification of potential NPAs.

Description

in 2025 the approach should improve last year's GSOC work on Features/Characteristics, Criteria and evaluation. The design and implementation of the screens should follow Mifos Application standards. Should implement statistical and ML methods with explainability on decision making. Should also be extensible for adding other functionalities such as fraud detection, cross-sell and up-sell, etc.

The system should be able to connect to external sources/providers(e.g. Credit Bureaus) to obtain a credit history that should weigh for the credit worthiness. The scorecard should be able to self update with increase and changes in data. This requires an ML pipeline to continually improve the scorecard models.

Priorities:

• Further optimize the ML and statistical models.

• Improve the Rule Based scoring system by fine-tuning the features.

• Setup ML pipeline to refresh dataset and models using Federated Learning techniques

• Implement Synthetic Data using SDV or any other open source synthetic data

• Extend the approach beyond Credit Scoring such as Fraud detection

Helpful Skills

JAVA, Integrating Backend Service, MIFOS X, Apache Fineract, AngularJS, ORM, ML, Statistical Methods, Django

Impact

Streamlined Operations, Better RISK Management, Automated Response Mechanism

Other Resources

Source Code: https://github.com/apache/fineract-credit-scorecard

Previous GSOC Progress

• 2024 Project (Parth Kaushal): https://github.com/openMF/scorecard-ai

• 2022: https://github.com/Zavier-opt/fineract-federatedLearning-research/blob/main/READEME.md Suchit’s Final Report - https://gist.github.com/sksDonni/53887ee6744330c4c8fbc1e18367331c

• 2021: https://gist.github.com/xurror/bba79ecbf063dd8eae8ee9c24732701e

• 2020: https://gist.github.com/humbletechy/43e7322913af561fdd7db5d4962d59a7

• 2019: https://gist.github.com/SupreethSudhakaranMenon/a20251271adb341f949dbfeb035191f7

Documentation

https://cwiki.apache.org/confluence/display/FINERACT/Fineract+Credit+Scorecard

https://gist.github.com/lalitsanagavarapu

Mentors

Ahmad Jawid Muhammadi Garvit Agarwal Saksham Handu Paras Dhama Rajan Maurya

Length

Large - 350 hours

Category

Mobile - Mifos X | Core Development

Overview & Objectives

In 2025, we are making a big push around shared infrastructure to provide modern core banking infrastructure the many SACCOs, MFIs and Credit Unions that go the last mile. We are prioritizing providing a more robust and feature-rich self-service mobile banking experience to be offered to their members and customers. Mifos Mobile is a reference mobile banking app which enables clients to authenticate themselves, view and edit their account details. and make repayments or transactions between their own accounts. It is now possible for any financial institution using Mifos to provide an omni-channel banking experience including smartphone-based mobile banking, USSD-based mobile banking, and online banking via a web app.

Over the years our interns extended our mifos mobile banking app, completing a mix of functional, architectural, and design improvements including improving the outbound notification system by migrating from GCM to FCM, initial integration with RocketChat for direct customer support between staff and clients, a dark theme and better support for skinning, and phase 1 of integration with Mojaloop via the payment hub. In 2020 Shivangi revamped the UI and Ashwin began the migration to Kotlin for mutli-module development and last year Avneet finished the kotlin multi-module migration and whole project get migrated xml to Jetpack compose.

With the payment hub and API Gateway now in place, next we look to add additional mobile money and payment system integrations into the app as well as having the app connect via the Open Banking API rather than the self-service APIs. This exercise of mapping the Fineract self-service APIs to the Open Banking APIs will be the major focus of this project.

It was built on top of the Apache Fineract 1.x client-facing APIs to enable self-service channels for clients to interact with their own data and transact in a self-service manner.

Description

In 2025, Work will involve both development of the Mobile application as well as work to connect the app securely via self-service middleware layer.

• Replace API layer from self-service Fineract APIs to self-service middleware layer

• Implement new look and feel based on modular UI components.

• Integration with an external payment system (Mojaloop, mPesa) via our PH-EE

• Complete migrate Kotlin multi-module to Kotlin Multiplatform.

• Make sure fineract-client-kmp-sdk implemented properly and have no bugs.

• Continue adding unit tests for Data Layer and UI Layer

• Cover all the screens with UI tests

• Implemented Playstore release github action pipeline

• Improve Githhub workflows and add jobs to run Unit and UI tests

• Add CI to build APK and code analysis.

Helpful Skills

Android, Kotlin, Kotlin Multiplatform, Jetpack compose, Coroutines, Koin, MVVM, Unit, Instrumentation Testing, Room, Git, OpenJPA, Rest, WS02 API Gateway

Impact

By providing an extensible mobile banking app, allow a member/client in having a self-service channel allowing them more direct control and visibility into their financial livelihood.

Other Resources

User Stories - https://goo.gl/3xuUko

Wireframes - https://goo.gl/3xuUko

Customer Self Service APIs - https://cwiki.apache.org/confluence/display/FINERACT/Customer+Self-Service

UK Open Banking API Standard: https://standards.openbanking.org.uk/

Source Code: https://github.com/openMF/mifos-mobile

See: https://openmf.github.io/mobileapps.github.io/

Mifos Webinar on Open Banking API: 

Mifos Open Banking API Documentation: https://app.gitbook.com/@mifos/s/docs/

GsoC 2020 work progress final report: https://gist.github.com/ShivangiSingh17/67b6041387c1e281caa7df23347f549e

GSOC 2023 Final Report (Pratyush Singh): https://gist.github.com/PratyushSingh07/a016afeb66d9b66b5aa01d232b10d788

GSOC 2024 final report (Avneet Singh): https://gist.github.com/AvneetSingh2001/5922dbbd905cd5f5e5f8ad3c0313fc4c

Mentors

 Subham Pramanik Paras Dhama Manoj VM

Category

Platform - Payments Integrations

Overview & Objectives

While we didn’t have an intern working on this in 2024 it’s very much a priority to both enable the ecosystem to independently adopt and extend PH-EE as well as to enable PH-EE to be utilized within the regions we’re deploying shared infrastructure to allow members to transaction digitally via mobile money.

Mobile money is rapidly transforming financial inclusion by providing more immediate, impactful, affordable, and secure financial services to the client. Providers like MFS Africa and Beyonic provide a set of cross-border payment rails to enable remittances across Africa terminating in mobile money wallets. Mobile money platforms like M-Pesa offer the client unparalleled value in terms of convenience, security and the possibility of new services and products that are more in line with real-world financial habits.  For financial institutions and their clients to fully scale mobile money and leverage its potential, it needs to be fully integrated with their core-banking system.

We designed and implemented Payment Hub EE as a highly flexible integration engine and orchestration layer to allow the ease of connecting to new mobile money APIs by simply building new connectors. Across the ecosystem, PH-EE has been deployed in production for multiple mobile money networks including M-Pesa via Safaricom and other connectors. However it is challenging for others to easily build new connectors. This project would help to make the process for building a new mobile money connector more replicable.

Description

This project would focus on making the process of building a connector more replicable, defining and templating the BMPN flows for inbound and outbound mobile transactions, properly documenting the process, creating a set of helm charts for deployment of Payment Hub EE for the mobile money integration use case.

The Payment Hub EE has been built out as an integration layer between Fineract and real-time payment systems like Mojaloop. Built around the Zeebe as an orchestration engine, it's built with an extensible architecture with a set of connectors for additional core banking systems, channels, and payment systems. We have a connector built for Mojaloop and the GSMA mobile money API and would like to build additional ones for the most widely used payment rails across our community. As part of our DIAL-funded project to integrate Mifos with the open source Mojaloop payments platform the team from DPC consulting built out a middleware component called the payment hub to enable the integration with the Mojaloop APIs. This middleware has also served as the point of integration for all other external payment systems - the payment hub is extendable by additional payment connectors.

Helpful Skills

Web Services, Java, SQL , JavaScript , Git, Sprint

Impact

Great efficiency, reduced risk for clients, more impactful and relevant products & services.

Other Resources

• 2020 Progress: https://gist.github.com/SubhamPramanik/905ea87b83dd0b6af62af18ca0c0c1ea

• Research & Data on Various Mobile Money Platforms  - http://goo.gl/XkSbdl

• Payment Hub EE Docs: https://mifos.gitbook.io/docs/payment-hub-ee/overview/payment-hub-apis 

• Overview of Payment Hub and How to Configure (See Section 5.6.3): https://docs.google.com/document/d/1XnAuWxmX-Fof7-o69IyU9ilwcmigqQ6dNHc9uNRx1r4/edit?usp=sharing

• Functional and Technical Specification on the Payment Hub: https://docs.google.com/document/d/1iVTgqljj5jW1eczpUcN_qykvWGh9bPKalxDayW8ZGcU/edit?usp=sharing

• Beyonic APIs: https://apidocs.beyonic.com/

Mentors

Ed Cable Victor Romero

Length

Large - 350 hours

Category

Web - Mifos X Online Banking App | Core Development

Overview & Objectives

It’s been a number of years since we have had an intern work on our online banking app but it’s a very high priority given the need for customers to interact with their own loan accounts. The online banking app is overdue for refactoring and could now follow the same Compose Multiplatform architecture as our mobile apps. It is currently an Angular web app powered by self-service APIs so would also follow the progress being made with self-service middleware layer. The app currently allows for account creation, logging in, viewing of account details, transferring between savings accounts, repaying loans via savings accounts, applying for new loans, and more.

Given the high amount of adoption of Mifos X for loan management use cases, for this year’s project we’d like to create a version of the online banking app which is solely focused lending use cases so Mifos can provide a customer-facing loan management portal. This will be a valuable community resource that others can use for demonstrations or to white-label to provide their customers to log into the self-service portal and view their existing active loans, view transaction details, repayment history, repayment schedules, etc, view details of previous loans, initiate repayments on their loans, calculate the payoff amount of their loans, apply for new loans, view loan account statements, etc.

LoanPro provides a valuable resources on what a simple loan management portal could offer at https://help.loanpro.io/article/fcflgkwnxn-customer-website

Description

• Focus for 2025 includes:

  • Redesign and Refactoring of Online Banking App to Compose Multiplatform

  • Align and enhancing overall user experience and design of application

  • Creation of a new repository that contains only the loan management self-service capabilities

  • Refine and implement the self-service loan management features listed above:

  • Incorporate better visuals and charts and dashboards around loan history

    • View their existing active loans

    • View transaction details, repayment history, repayment schedules, etc

    • View details of previous loans

    • Initiate repayments on their loans

    • Calculate the payoff amount of their loans

    • Apply for new loans

    • View loan account statements, etc.

  • Deploy the APIs (back-office or self-service APIs) securely (i.e. API Gateway)

  • Implement capabilities to configure a more customized look and feel of the app (upload logo, etc.)

  • Leverage ongoing security enhancements in Fineract to provide better self-service user management

  • Ensure the app can easily be embedded or integrated into existing tools of institutions using this.

  • Bonus: Enabling self-service external transactions through Payment Hub EE integratio

  • Bonus: Adding new support features to make app more user friendly.

Helpful Skills

Angular development, SQL, Java, Javascript, Git, HTML, CSS

Impact

Allows a member/client in having a self-service channel allowing them more direct control and visibility into their financial livelihood.

Other Resources

Previous GSOC Efforts:

• 2020 Progress: https://gist.github.com/manigedit/bca72537151afde40a3246776cb22503

• 2019 Progress: https://gist.github.com/CajetanRodrigues/b2b14b55f0f2c97ea276eb764209c4d9

LoanPro Customer Loan Website: https://help.loanpro.io/article/fcflgkwnxn-customer-website

Self Service APIs - https://cwiki.apache.org/confluence/display/FINERACT/Customer+Self-Service

Source Code - https://github.com/openMF/web-self-service-app and https://github.com/openMF/online-banking-app

Complete Details can be found here: Self Service Web Application

UK Open Banking API Standard: https://standards.openbanking.org.uk/

Mifos Webinar on Open Banking API: 

Mifos Open Banking API Documentation: https://app.gitbook.com/@mifos/s/docs/

Further Ideas: https://docs.google.com/document/d/1KXDSrBkuYA9g694-DE4qf1QKFcAhWwA-HNnn9YAucbk/edit?usp=sharing

Mentors

Bharath Gowda Victor Romero

Overview & Objectives

Business insights are not just raw data; they are the outcome of a thorough analysis that transforms data into valuable information. By examining data from multiple sources, such as sales records, customer feedback, and market research, organizations can gain a comprehensive understanding of their business landscape.

Through the application of analytical techniques, such as data mining, statistical analysis, and machine learning, organizations can uncover hidden patterns and correlations within their data. These insights provide a deeper understanding of customer behavior, market trends, and operational efficiency.

During previous GSoC Interms have developed ETL scripts to create OLAP cubes (fact and dimension tables on MySQL). This allowed managers to perform ad hoc slicing and dicing of their data to answer important questions about their operations.

• Created ETL scripts and tests

• Created a Mondrian schema to work with Saiku Analytics

This previous project would extend off of the work of a previous GSOC intern in building out integration with Saiku.

The proposed work is looking to use MPP-based real-time data warehouse (like Apache Doris) for ingesting data from Mifos X and the Analytics can be implemented as Dashboards using Apache Superset.

Description

The data and information housed in the centralized Mifos database is critical to the operations and management of a financial institution. While Mifos X ships with more than five dozen standard report and has multiple ways to build custom reports, non-technical staff who don’t know SQL queries nor the structure of the database struggle to be able to access new reports on the fly. Integration with Saiku would allow for ad-hoc reporting or more simply a drag and drop interface for management and non-technical staff to easily slice and dice and create reports on the fly.

Nowadays using near real time data is critical for Decisioning systems and the core banking solutions are a crucial component for any financial institution. And the use of modern open source technologies can give Business Insights on the ever-changing business landscape for taking informed decisions.

At a later time the data lake could be used for using another AI tools for data analysis.

Helpful Skills

Database Management Systems, MDX, SQL,

Impact

Data drives a microfinance institution - the more powerful and robust analytical tools management has, the better they can tailor their services and outreach to impact the poor most effectively.

Other Resources

Apache Doris - https://doris.apache.org/

Apache SuperSet https://superset.apache.org/

TiDB - HTAP Database - https://www.pingcap.com/

Saiku Analytics Demo - demo.analytical-labs.com
Wikipedia OLAP Article - http://en.wikipedia.org/wiki/Olap
Introduction to OLAP - http://www.db-class.org/course/video/preview_list
Gentle Introduction to MDX - http://www.iccube.com/support/documentation/mdx_tutorial/gentle_introduction.html

• Apache Fineract 1.0 Github Repo

• Saiku Github Repo

• https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=73632010

• Ad Hoc Reporting Builder Tool

• GSOC Idea Description

• Demo of Integration from 2014

• Saiku Website - http://community.meteorite.bi/

• Documentation on Work led by Oleg in 2014

• JIRA Issue for Oleg’s Work: https://mifosforge.jira.com/browse/MIFOSX-1448

• Source Code from Oleg’s Work

• Discussion on Saiku and Challenges to Overcome

• Discussion on Saiku

• Demo of Mifos with Salesforce Reporting

MIFOSX-1448 - Getting issue details... STATUS

Mentors

Ed Cable

Category

Back-end Platform | Modules

Overview & Objectives

Right now Mifos X contains core client management functionalities including tracking basic demographic information, know your customer information, document management, and survey collection through data tables. As financial institutions, serving the poor begin to offer a more in-depth and diverse range of financial inclusion products, the need for more robust client management and in-depth client understanding has grown. Their core system needs to provide more and more CRM-type functionality that compliment the portfolio management and financial/social reporting that the Mifos X provides.

This project will work to deliver the initial set of customer relationship management functionalities including a module for tracking inquiries, complaints. Primarily it will focus around customer support desk type functionality.

Description

This module will have a request management functionality. A request can be of 2 types: Complaints and Service Requests. Each request must be against a customer and optionally against an account of the customer. Each request will go through a simple workflow.

Actions that can be performed on a request:

Assign -> will change status to "assigned"

Start Work --> will change status to "in progress"

Close --> will change status to "closed" (with a sub-reason code)

At each step user can enter comments.

The customer summary screen will have a link to view the requests of the customer - along with a summary and current status - with options to click-through to get the complete history of each request.

Helpful Skills

familiarity with Mifos X tech architecture, angular js,node js, java,Spring, Backend Integration

Impact

Deepening the client relationship and ensuring fair, responsible, and transparent financial services to the poor is a core piece of the industry's roadmap for financial inclusion. Providing customers the ability to voice their concerns and feedback about the services they're receiving provides a simple yet powerful tool to protect the client. Empowering the financial institution with the ability to track these inquiries and overall maintain a more holistic relationship tracking entire lifecycle of their clients gives them a much better ability to understand their clients and respond to their needs with appropriately designed services and products.

Other Resources

• Odoo Open Source Business Apps Github Repo

• Odoo Third-party API And Demo

• Wikipedia Article on CRM

• What Is CRM ?

• CRM

Mentors

Kerlyn Manyi

Length

Medium - 175 hours

Category

Platform | DevOps | PH-EE

Overview & Objectives

Mifos Payment Hub EE is a critical financial transaction platform that facilitates seamless payments across different banking and financial services. Given its complexity, ensuring the system's long term resilience, scalability, and security is vital. This project aims to perform AI-driven architectural testing to analyze the system’s performance, identify bottlenecks, predict failures, and enhance its overall robustness.

Description

By leveraging machine learning and automation, the project aims to create an intelligent testing framework that can proactively detect issues before they impact operations. This will result in improved performance, enhanced security, and better fault tolerance for Mifos Payment Hub EE.

Intern will;

1. Develop machine learning models for anomaly detection, load testing, and vulnerability scanning.

2. Implement AI-driven load and stress testing to identify system bottlenecks and optimize performance.

3. Utilize AI-based security scanning tools to analyze authentication mechanisms, APIs, and transaction flows. Detect potential fraud patterns using machine learning techniques.

4. Design an AI-driven test automation framework to reduce manual testing efforts. Implement predictive analytics to forecast potential system failures.

5. Document testing processes, findings, and recommendations.

Helpful Skills

Python, Java, TensorFlow, Scikit-learn, Git

Impact

The project will boost Mifos Payment Hub EE's long term reliability and security while enabling scalability, ultimately establishing it as a trusted choice for financial institutions.

Other Resources

Mentors

jeremy engelbrecht Akshat sharma

Length

Medium - 175 hours

Category

AI | Platform - Modules

Overview & Objectives

Mifos is a powerful loan management system, but it has room to improve its loan origination and decision-making features. Phase 2 of the Bank Statement Analysis project enhances the system by integrating user personalization and expanding cross-platform compatibility. With this, the platform will not only analyze the credit risk of potential borrowers but also provide personalized financial advice based on the user’s spending habits, income, and goals. Additionally, this phase will improve integration with various financial platforms, creating a more comprehensive financial management experience for the user.

Description

In this phase,the system will build dynamic, personalized user profiles based on financial data. It will also integrate seamlessly with multiple financial platforms to aggregate data from various sources such as bank accounts, investment portfolios, and payment services.

Key features in Phase 2:

• Personalized Financial Advice: Provide tailored recommendations based on historical spending, income, and financial goals. These suggestions will include budgeting tips, savings strategies, and financial goal tracking

• Cross-Platform Integration:

  • APIs & Data Standardization: Create robust APIs and standardized data formats for seamless data exchange between multiple financial systems.

  • Real-Time Synchronization: Enable real-time synchronization and data aggregation from various financial sources such as banking accounts, investment portfolios, and payment services.

  • Uniform Interface: Provide a uniform interface for consolidating financial records across different platforms, ensuring a unified experience for users.

These features will be integrated within MIfos X, allowing users to access a comprehensive overview of their financial data and receive personalized advice, all while improving their loan eligibility assessment.

Helpful Skills

Python, XGBoost, NLP, Recommendation Systems, Cross-Platform Data Integration

Impact

Phase 2 will significantly improve the loan origination process by offering dynamic, personalized financial recommendations. It will also enhance the user experience by allowing real-time synchronization of financial data across multiple platforms, giving users a comprehensive view of their financial situation. The cross-platform compatibility will foster a more integrated financial management experience, helping users make informed decisions, optimize their finances, and improve their creditworthiness for loan eligibility

Other Resources

For similar work that has been worked on previously in the community, see: https://mifos.org/blog/powered-by-mifos-softidoc/

2024 GSOC Final Report (Akshat Sharma): https://gist.github.com/Akshat111111/2f5212f95dab3e6ab6cf12ee7aef5584

Mentors

Nayan Ambali, Ed Cable Rahul Pawar

Length

Medium - 175 hours

Category

Platform - Modules | Core Development

Overview & Objectives

Mifos is a very strong loan management system but has room to improve around loan origination features. Credit Bureau integration is one of these key features to build upon. Because of regulatory reasons or to do background check of a client (risk management), MFIs depend on credit bureaus. As part of it, MFI must submit client details to credit bureau and also need to pull client information from credit bureau before approving any new loans to a client. Mifos X can be integrated with a popular CBs in India and from other regions (based on the demand).

Description

During the 2016, 2017, and 2020 Google Summer of Codes, Nikhil Pawar and Rahul Pawar completed the credit bureau integration module with integrations for the major credit bureaus in India and Myanmar. This project will continue extending the functionality of the module and work on integrations with the major credit bureaus in Latin America and Sub-Saharan Africa.

The major functionality will be sending the data to CBs on regular intervals in the format CB expects. And option to pull the client’s information from CB whenever loan officer/branch manager/ user wants to view the information for a particular client.

During 2025 it is expected to integrate a Credit Scoring standar which is the FICO® (Fair, Isaac, and Company). Although FICO® has many different scoring models, it uses relative percentage weights to help determine how much impact certain factors will have in helping determine a FICO® credit score. The main categories considered are a person’s payment history (35%), amounts owed (30%), length of credit history (15%), new credit accounts (10%), and types of credit used (10%).

The Credit Burea information can be displayed while creating a new loan application because it will be used only during this process.

Helpful Skills

 SQL, Java, Javascript, Git, Web Services, Big Data (Hadoop, Hive), API Rest,

Impact

The credit report shows account information such as repayment record, defaults, type of loan, amount of loan, etc. of the customer. This information facilitates prudent decision-making when the credit underwriter processes the loan application. This help MFI to reduce the risk of bad loans and reduces the multiple lendings to same person from different MFIs.

Other Resources

For the scope of this project for 2024, see https://jira.apache.org/jira/browse/FINERACT-734

Detailed requirements https://goo.gl/aZWMZa

Mifos Credit bureau Integration. (Risk calibration Module -RCM)

Source Code: https://github.com/apache/incubator-fineract/pull/215

FICO - https://www.fico.com/es/products/fico-score

EQUIFAX - https://www.equifax.com/personal/education/credit/score/articles/-/learn/what-is-a-fico-score/

Credit Scores - https://en.wikipedia.org/wiki/Credit_score_in_the_United_States#FICO_score

MyFico - https://www.myfico.com/credit-education/credit-scores

Mentors

Ed Cable Mohit Bajoria Jose Hernandez

Length

Medium - 175 hours

Category

Web 

Overview & Objectives

For our Payment Hub EE integration layer and payment orchestration engine, we provide an operational user interface which allow staff of the financial institution participating in a real-time payment scheme to manage view detail of the incoming and outgoing transactions that are flowing through the switch, manually process refunds, complete reconciliations, view and take action on unsuccessful and disputed transactions, and more. 

Description

Intern will improve the operations app user interface for the following use cases.

• Transaction Details View

• Transaction Reconciliation

• Refund/Reverse transactions

• Operational Metrics and Dashhboards

• Business metrics and Dashboards Account Details

Helpful Skills

Javascript, CSS, HTML5. Angular and Bootstrap (CSS framework) is plus

Impact

Reference UI for microfinance institutions on Apache Fineract CN

Other Resources

Usability and Design

Use Cases - https://github.com/openMF/digital-bank-ui/wiki/Use-Cases-&-Requirements

Github

https://github.com/openMF/digital-bank-ui

https://github.com/openMF/digital-bank-ui/issues

Mentors

Godfrey Kutumela

Length

Medium - 175 hours

Category

Platform | Infrastructure

Overview & Objectives

Mifos Payment Hub EE is continuing to grow in its functional capbailities and breadth of use ceases being adopted for. We must ensure it is super secure and impenetrable. Your mission, should you choose to accept it, is to prove us wrong, and help close gaps you may find.

Description

Beyond a one time exercise, you should integrate (some of) the tools you've used into our build chain so that, even after you've gone, tools flag up future newly introduced potential vulnerabilities.

Helpful Skills

Candidates applying for this project would ideally have prior experience in penetration testing, and document this in their application.

Impact

Re-assuring the more Entreprise-y type Mifos clients that they can safely bet on Mifos X as an MFI platform.

Other Resources

https://www.owasp.org/index.php/Main_Page

https://code.google.com/p/zaproxy/

http://wapiti.sourceforge.net

Run FindBugs & related tools for some serious static code analysis

http://en.wikipedia.org/wiki/Penetration_test

Mentors

Rachit Kansal

Length

Medium - 175 hours (Update)

Category

Platform & Modules - ID, Exploratory, Bleeding Edge

Overview & Objectives

Digital Identity is a pressing topic and for both generations of Fineract (1.x and CN), we'd like to have integration with emerging KYC and digital identity solutions.

KYC (Know your customer) is a fundamental banking concept. It refers to the process of identifying a new customer at the time of account opening, in compliance with law and regulation. The identification requirements may be lower for low value accounts ("Tiered KYC"). The term is also used in connection with regulatory requirements for a provider to understand, on an ongoing basis, who their customer is and how they are using their account. Most of the banks are mandated to perform basic/extensive KYC, before they can serve their customers.

Traditionally KYC is done in a centralised fashion where a central agency has the control over all the data. For example consider each bank like SBI, Deutsche, JP Morgan, etc. when creating a bank account, each of them requires a separate KYC process to be completed and all this data gets stored in their respective databases. Even the systems like Aadhar or social security number, etc. have the data stored in a central manner and maintained by the government. However, in recent times all these centralised identity servers continue to be hacked and the important and private data being stolen regularly.

With the advent of blockchain concepts and technologies, it is not ideal but imperative that we shift from the traditional identity management to a more secure decentralised claim-based identity management system. This kind of system has multiple benefits:

• Decentralised system means that no one person has control over sensitive data.

• It enables the re-use of KYC, i.e. each financial institution or in our case each customer using Fineract may not have to perform its own complete KYC, but re-use the KYC already performed by others (those who have the power as issuing authority for any kind of claim).

• Cryptographic security is the heart of blockchain technologies enhancing privacy.

• Claim-based system where the end user/customer has the control over his data.

Description

See https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=103093257  for details on the proof of concept 

P0 requirements

1. Setup and run an Hyperledger Indy Network with Stewards.

2. Opening a bank account scenario.

3. Applying for a loan scenario.

P1 requirements

1. Performing money transfer to a merchant online.

Helpful Skills

HTML, Spring, Hibernate, REST, Java, AngularJS, Javascript, SQL, Hyperledger Indy

Impact

Other Resources

• Sovrin: https://sovrin.org/

• Indy Getting Started: https://github.com/hyperledger/indy-sdk/blob/master/docs/getting-started/indy-walkthrough.md

• Sovrin Whitepaper: https://sovrin.org/wp-content/uploads/2018/03/Sovrin-Protocol-and-Token-White-Paper.pdf

• Sovrin Stewards: https://sovrin.org/stewards

Mentors

raul.sibaja Aleksandar Vidakovic jeremy engelbrecht

Length

Medium - 175 hours (Update to Large)

Category

Platform - Modules | AI | Exploratory

Overview & Objectives

For many of our users today, chat is a much more familiar form of user interface for them and it would be valuable to provide an extensible chatbot connected to Mifos/Fineract that could be used to both provide customer support as well as allow clients to directly interact with their accounts. See this post from ThitsaWorks for more: https://medium.com/@thitsaworks/chatbots-the-emergent-and-effective-tool-in-financial-education-f6e63baf9188

Description

This project will focus on building on the latest version of the chatbot. In 2019, our GSOC intern, Anshul extended the Mifos Chatbot and Adapter with better authentication, improved Natural Language Processing, and integration with the Slack, Telegram and Facebook messenger platforms. 

The project will include both leveraging other open source libraries and components to build the chatbot and building the adapter to the chatbot for MIfos/Fineract which will act as the interaction between chatbot and Mifos. It will take the replies from chat and feed them into Mifos. The program will sit in between Mifos and Chat.

Main components needed are:

1. NLU (natural language understanding) /NLP (natural language processing)
   This componentcomponent is probably a good candidate for integrating a suitable existing OS project. 

2. Chat platform and/or protocols
   To establish the communication between user and the bot logic the project could either leverage (at least) one of the major chat platforms (e. g. Facebook messenger etc.) and/or use open source protocols like XMPP or IRC. It's probably best to evaluate existing chat frameworks/client libraries 

3. Fineract adapter
   This is the part where most of the student's attention is needed (see use cases below). The student would have to evaluate to which extent a chatbot framework could be integrated or if there are better arguments to develop something Mifos specific.

Note: only Apache license compatible libraries/frameworks/components can be used.

It will cover the following use cases: 

• Enquiry of Loan Details

  • Mifos/Chat adapter will allow authenticated user to enquiry details of loan based on loan ID.

  • Check user/client authentication

  • Get MFI name, 9-digits loan ID (xxxxxxxxx), 9-digits clients ID (xxxxxxxxx) if it is an authenticated user/client.

    • Allow authenticated user/client to query loan details:

    • Status of loan

    • Outstanding principal and interest

    • Next due date, due principal and interest

    • Previous payment date, principal and interest (the last transaction of loan)

    • Loan maturity date

    • Overdue loan principal and interest (if have)

    • Number of days in arrears for loan

    • Penalty fees/charges

    • Client activation date

    • Loan disbursed date/amount/interest

    • First repayment date

    • Saving balance

    • Saving interest (to date amount)

    • Next meeting date

  • Enquiry of Savings Details

    • Saving activated date

    • Saving balance

    • Saving interest (to date amount)

    • Last active transaction date

  • Notifications through Chat Adapter

    • Notification will be sent thru Mifos/Chat adapter to respective clients on the following events occur on their accounts. 

      • Client account activation

      • Client account rejection

      • Loan disbursal

      • Loan close

      • Next due principal and interest (1/2 days in advance)

      • Payment posted (there may have delay due to data entry)

      • Next meeting date

      • Saving deposit

      • Saving withdrawal

      • Saving close

      • Update/delete details of clients (address, phone number, NRIC number)

      • Update/delete details of group (group name, group leader, loan officer name)

      • Upload documents

  • Enquiry about Loan Products

    • Check user/client authentication

    • Get MFI name, 9-digits clients ID (xxxxxxxxx)

    • (Provide a list of available loan products of MFI)

    • Allow authenticated user/client to query loan product details based on selected product:

      • Loan term

      • Interest rate

      • Max and min allowed amount to borrow

      • Number of installments/repayments

  • Enquiry about Group Information

    • Mifos/Chat adapter will allow authenticated user (group leader) to enquiry on group member details.

    • Check user/client authentication.

    • Get MFI name, group leader name, group ID, center ID, branch name, (Is a group leader?)

    • Allow authenticated client(group leader) to query group details:

      • Next meeting date

      • Clients who have overdue loan

  • Enquiry about Branch Information

    • Mifos/Chat adapter will allow authenticated user(branch manager) to enquiry on branch details.

    • Check user/client authentication

    • Get MFI name, branch manager Name, user id/name, Branch Name, (Is a branch manager?)

    • Allow authenticated branch manager to query branch details:

      • Number of clients of his/her branch

      • Expected disbursement principal (today)

      • Outstanding principal and interest

      • Saving balance

      • Number of clients awaiting for disbursal (today)

      • New registered clients (today)

      • Prospective clients (as of today)

      • Number of clients (dormant) as of today

      • Number of village/bloc/ward in a branch

Helpful Skills

SQL, Java, Git, Spring, OpenJPA, Rest

Helpful: technical knowledge of (any) chat protocol (e. g. XMPP, IRC), experience with NPU/NLP

Impact

Other Resources

2019 Progress: https://gist.github.com/iosdev747/2b7de87cd9b028bb97433ee2e26ad18d

Source Code: https://github.com/openMF/mifos-chatbot

AI/NLU services
Google: https://dialogflow.com/
Facebook: https://wit.ai/
https://botkit.ai/
https://www.ambiverse.com/
https://github.com/ambi-verse/nlu-api-client-java

Frameworks
https://github.com/howdyai/botkit
https://github.com/nitroventures/bot4j
https://dev.botframework.com/
Has a lot of information on integration with chat platforms/protocols: https://github.com/BotMill

NLP/NLU components and tools
https://opennlp.apache.org/
https://deeplearning4j.org/java-ai
https://github.com/AIMLang/aiml-java-interpreter
https://nlu.rasa.ai/

Tutorials
https://dzone.com/articles/building-an-intelligent-chatbot-using-botkit-and-r
https://dzone.com/articles/beginners-guide-to-creating-chatbots-using-dialogf-1
https://tutorials.botsfloor.com/

Other
Extensive comparison: https://chatbotsjournal.com/25-chatbot-platforms-a-comparative-table-aeefc932eaff
Seems outdated, maybe helps with some insights/inspiration: http://www.zionsoftware.com/products/jbuddy/botframework/

Mentors

Nayan Ambali

Length

Medium - 175 hours

Category

Platform & Web

Overview & Objectives

Financial Inclusion providers need a comprehensive view into the overall livelihood of their client both for better risk analysis, credit scoring, as well as social performance management.

Description

We have the back-end in place for a surveys/social performance management framework that allows the import of XMLs for the PPI (progress out of poverty index) SPM scorecard. We need to implement a front-end UI for viewing and recording PPI surveys as well as a UI in which to create new surveys from scratch (similar to Question Groups in an older version of software).

1. Build out the UI for creating survey from available PPI scorecard

2. Capture/record surveys from a given entity in the web app

3. View recorded surveys from the web ap

4. Interface to create new surveys from scratch via the UI

See Resources below for specs/wireframes.

Helpful Skills

HTML, Spring, Hibernate, REST, Java, AngularJS, SQL  

Impact

Ability to measure social impact and have one single point of information on a client within the platform.

Other Resources

See https://cwiki.apache.org/confluence/display/FINERACT/Social+Performance+Management+Framework

These are the legacy docs on the old question group functionality: https://mifosforge.jira.com/wiki/display/MIFOS/Question+Groups+and+PPI
and http://www.flossmanuals.net/mifos-user-manual/how-to-add-a-question-group/

Wireframes

Mentors

David Higgins Ed Cable

Length

Medium - 175 hours

Category

Platform - Modules | AI | Exploratory

Overview & Objectives

The community for Mifos related applications has grown considerably over the past few years. The applications are highly complex and implementors (especially those new to the projects) require support to be able to implement and develop these applications.

Current support is via the Slack general channel and dispirate documentation, requests get different treatment depending who reads and responds. As there is no dedicated resource for monitoring and response which means timescales can be elongated.

The objectives of this project is to setup an initial AI bot and learning algorithm that can respond to questions and point users to the relevant answers or documentation.

This would need to be across the range of Mifos/Fineract products that the slack channel currently accomodiates

it would require some pre-training of the algorithms based on past questions

Description

Identify the best AI solution for the task.

Create the AI PoC and train the algorithms

Test its responses based on previous questions and answers.

PoC could be limited to one product initially and have a breakout for additional assistance.

Web integration e.g. chatbot could be added to websites.

Helpful Skills

HTML, Slack, AI

Impact

Other Resources

Mentors

Ed Cable David Higgins

Length

Small - 90 hours

Category

Mobile Development

Overview & Objectives

Mifos and Fineract are valuable Digital Public Goods critical to advancing the Sustainable Development Goal of No Poverty by providing both the core banking system of record to manage the store of value for a functional wallet/transactional account in which to send G2P payments to. Many different financial services can be layered on these accounts within Mifos and Fineract making them a powerful tool for financial inclusion. Apart from providing the back-end to manage these wallets, Mifos also provides a reference mobile wallet which can be extended to one’s local requirements.

Recently there have been a number of cross-sector movements to establish standards and frameworks upon which any type of wallet could be built. These wallets could be used for financial use cases, identity use cases, health use cases, etc but standards and frameworks initial focus primarily centers around secure sharing of credentials and privacy of user data.  Mifos was a founding member of the Open Wallet Foundation and sits on the GovStack Wallet Building Block Working Group. 

Description

This project would consist of researching the different open wallet standards emerging from the Open Wallet Foundation, GovStack wallet building block, and could utilize other digital public goods for identity including Inji from MOSIP and the Gluu Project. 

Research would include exploring the current status of the specifications, standards and designing a POC architecture for a mobile wallet that aligns with th standards and specifications in their current state. 

Helpful Skills

Java, Android, Kotlin, Mobile Development, Enterprise Architecture

Impact

The OWF aims to set best practices for digital wallet technology through collaboration on standards-based OSS components that issuers, wallet providers and relying parties can use to bootstrap implementations that preserve user choice, security and privacy. (mission of Open Wallet Foundation)

Other Resources

Open Wallet Standards & Requirements

• https://openwallet.foundation/

• https://www.linuxfoundation.org/research/open-wallet-foundation

• https://govstack.gitbook.io/bb-payments/

Open Source Tools for Identity & Credential Sharing

• https://gluu.org/

• https://docs.mosip.io/inji/overview

Mentors

Ed Cable David Higgins

Length

Small - 90 hours

Category

Payments | Platform - Integrations

Overview & Objectives

A huge democratizing force across the financial services sector is the Open Banking movement providing Open Banking APIs to enable third parties to directly interact with customers of financial institutions. We have recently started providing an Open Banking API layer that will allow financial institutions using Mifos and Fineract to offer third parties access to requesting account information and initiating payments via these APIs. Most recently the Mojaloop community, led by Google, has led the development of a centralized PISP API.  We have chosen to the folow the comprehensive UK Open Banking API standard which is being followed and adopted by a number of countriues through Sub-Saharan Africa and Latin America. The Interledger Foundation now also has an Open Payments Standard.

All of these standard have great applicability to how our core banking and payment orchestration systems authorize, establish consent, access date, and initaite transactions via these third party APIs and standards for sharing information and initiating transactions

Description

This project would consist of researching the all of the different open banking, open finance and open payment initiatives and their corresponding API specifications. The POC would consiste of designing and implementing ways in which Fineract could generate APIs that are compliant with these specifications and most importantly ways for Fineract and our Payment Hub EE to consume the APIs/standards for these initiatives.

Helpful Skills

Java, Android, Kotlin, Mobile Development, Enterprise Architecture

Impact

More innovation, control, and access as they can securely enable third parties to access their data and initiate transactions on their behalf.

Other Resources

Open Banking & Open Finance Standards & APIs

• Mojaloop Third Party API - https://docs.mojaloop.io/api/thirdparty/

• https://www.openbanking.org.uk/

• https://github.com/interledger/open-payments

Mentors

David Higgins

Length

Small - 90 hours

Category

DevOps

Overview & Objectives

Mifos Gazelle deploys a number of components (DPGs) that can be used in end to end payment flows. The idea of Mifos Gazelle is that these can then have end to end demos run across them potentially linking to other systems external of the environment.

Description

This project would consist of researching a potential use-case. Defining the use-case and how it would flow within the environment. Identify any integrations with external components needed and using existing APIs to do this perhaps with the assistance of an external workflow system such as OpenFN. Creating the demo script, configurations for environment, demo data. Ensuring replicability e.g. that it could be repeated on a fresh install with low technical skill. Documentation, presentation are key for this, this could be an idea webinar or demo/talk at a conference or event.

Basically this project is limited by your imagination.

We can support multiple iterations of this project for different use-cases or it could be scaled up looking at multiple use cases to be a larger project.

Helpful Skills

Javascript, DevOps, Enterprise Architecture , soft skills such as research, impact understanding, presentation skills are as important.

Impact

This would enable DPI implementors to understand better the use cases within the Payments Ecosystem, accelerate the path to deployment increase adoption and increase financial inclusion

Other Resources

Mifos Gazelle : https://products.mifos.org/mifos-gazelle/

• Mentor since 2021

Web

India

IST (GMT +5:30)

• Mentor since 2023

DevOps

Australia

AEDT (GMT+11:00)

• Mentor since 2023

• Summit delegate in 2023

AI

South Africa

SAST (GMT +2:00)

• GSOC intern in 2020

• Mentor since 2021

Mobile

India

IST (GMT +5:30)

• GSOC intern in 2024

• Mentor in 2025

Web

India

IST (GMT +5:30)

• GSOC intern in 2024

• Mentor in 2025

AI

India

IST (GMT +5:30)

• Mentor since 2023

• Delegate to summit in 2023

Security

South Africa

SAST (GMT +2:00)

• Mentor since 2024

• Org Admin in 2025

AI

United Kingdom

GMT (GMT +0:00)

• GSOC intern in 2020

• Mentor since 2021

AI

India

IST (GMT +5:30)

• GSOC intern in 2016

• Mentors since 2017

Mobile

Canada

EST (GMT -5:00)

• GSOC intern in 2024

• Mentor in 2025

Mobile

India

IST (GMT +5:30)

• GSOC intern in 2023/2024

• Mentor in 2025

Mobile

India

IST (GMT +5:30)

• GSOC intern in 2023/2024

• Mentor in 2025

Web

India

IST (GMT +5:30)

• GSOC intern in 2023

• Mentor in 2025

Security

India

IST (GMT +5:30)

• GSOC intern in 2018

• Mentor since 2019

Platform

USA

EST (GMT -5:00)

• Mentor since 2018

Platform

India

IST (GMT +5:30)

• Mentor since 2021

Platform

Mexico

CST (GMT -6:00)

• Mentor since 2022

Platform, Web, Mobile

Mexico

CST (GMT -6:00)

• Mentor since 2022

Platform

India

IST (GMT +5:30)

• GSOC intern in 2018

• Mentor since 2020

AI

India

IST (GMT +5:30)

• C4GT intern in 2024

• Mentor in 2025

DevOps

India

IST (GMT +5:30)

• Mentor since 2017

Platform

Serbia

CET (GMT +1:00)

• GSOC intern in 2023

• Mentor in 2025

Security

Cameroo

(GMT+1:00)

• Mentor since 2018

• Org Admin since 2019

• Summit Delegate in 2024

Platform

india

IST (GMT +5:30)

• GSOC intern in 2017

• Mentor in 2018

• Org Admin in 2019/2020

Platform

India

IST (GMT +5:30)