10%

Try : Insurtech, Application Development

Edtech(5)

Events(34)

Interviews(10)

Life@mantra(11)

Logistics(1)

Strategy(14)

Testing(8)

Android(45)

Backend(29)

Dev Ops(2)

Enterprise Solution(22)

Frontend(28)

iOS(40)

Javascript(13)

Augmented Reality(17)

Customer Journey(12)

Design(13)

User Experience(34)

AI in Insurance(31)

Insurtech(59)

Product Innovation(37)

Solutions(15)

E-health(3)

HealthTech(8)

mHealth(3)

Telehealth Care(1)

Telemedicine(1)

Artificial Intelligence(109)

Bitcoin(7)

Blockchain(18)

Cognitive Computing(7)

Computer Vision(8)

Data Science(14)

FinTech(44)

Intelligent Automation(26)

Machine Learning(46)

Natural Language Processing(13)

Here’s how Neobanks are Changing the CX game in Banking

4 minutes read

“To change behavior, products must ensure the user feels in control. People must want to use the service, not feel they have to.”― Nir Eyal

Our life revolves around Swiggy, Uber, Dunzo, Urban Clap, and hundreds of applications that give us instant service, usage insights (for example, Swiggy shows the amount of money saved per month through the application usage), rewards, and personalized notifications. Customers are now addicted to this kind of habit and want similar experiences everywhere. What if they can have a banking experience in the same way they order food over Zomato or book an Ola cab via a mobile app. Neobanks are the Swiggy, Zomato of the banking world. Neo is a Greek word that means new. Neobanks are the modern version of traditional banks. Let’s look at how neobanks are changing the CX game in banking industry.

NEO Banks and the Gen Z

Gen Z’s (Generation Z) are the newest addition to the banking world. This generation has a deeply embedded expectation that everything they search for or buy online will be tailored and delivered right away. 

Additionally, Gen Z is a value-driven generation that seeks more value for their money. Their expectations are hyper-personalized experience, prompt deliveries, and on-demand services, higher user engagement, and value for money. And neo banks have been the first movers in decoding these expectations. They are positioning their brand as an online platform for millennials and Gen Z, offering financial services at a touch of a button. Their USP is convenient and simple user experience

For example, Jupiter money- a 100% digital banking company designed to target Gen Z and Millennials- helps users open an account within 3 minutes. “Jupiter has 3 main areas of focus at the moment — increasing user engagement on the platform, investment options, and introducing consumer lending services, which will help them monetize the platform”, says the company’s founder and chief executive officer (CEO) Jitendra Gupta. 

Neobanks are making it easy for users to keep a track of their expenses, and save and plan their investments wisely. But what else is different about them? Why are Gen Z and millennials hooked on this modern banking platform? Well, it’s all about the first impression. Neobanks have built the mobile app keeping the new Generation’s daily routines, actions, and habits in mind. They studied user behavior patterns to determine what compels and ticks these newer customer segments. Here’s how neobanks are changing the CX game in banking to win customers: 

  1. Real-time financial insights at the tip of a button: Customers can track their spending, saving status, and every financial activity on the app. 
  2. Interactive & Conversational App Design: Neobank apps do not have any physical branch yet they are appealing because of their amazing UI and application design. The look and feel of the application is more youthful and vibrant with a minimalistic design. Their focus is on user experience design and functionality, both.
Here's How Neobanks are Changing the CX Game in Banking
Here's How Neobanks are Changing the CX Game in Banking

Source: Jupiter

  1. Rewards & Benefits: Neobanks offer attractive offers and rewards to bring back users repeatedly on the app and retain them. For instance, customers get a 1% reward on all UPI and debit card purchases using Jupiter Money. They can also track their reward earnings in real-time. 

Where are the Traditional Banks heading towards?

Conventional banks focus more on the functionality of the application. Earlier, customers had to visit the branch physically to avail of banking services. Now they focus on bringing the banking service to the user’s ecosystem. Data and AI-driven personalization have been helping banking institutions to create seamless customer journeys for the users. They are leveraging technologies like metaverse, Virtual Reality (VR), and Augmented Reality (AR), to create offerings in the virtual world. Their USP (Unique Selling Proposition) is Customer Engagement. Gen Z is spending most of the time in this virtual space. Banks are leaving no stones unturned to mark their presence in the customer’s ecosystem. How? By creating an immersive experience for these users in the virtual space. IndusInd Bank launched a video branch, which allows customers to communicate with their bank executive in real-time. 

JP Morgan opened a lounge- Onyx in Decentraland. Bank of America launched VR training in over 4,300 financial centers. Lynx is working on introducing 1) A cryptocurrency-based game that allows players to create, earn and sell digital items with financial value and 2) An“enhanced remittance experience”:  A digital meeting space that allows those sending money to loved ones to visit and communicate with them in a “streamlined, entertaining, economical, and secure” manner.

The Road Ahead:

The Reserve Bank of India hasn’t allowed banks to become fully digital. This is one of the major challenges for Neobanks. Having a completely digital presence, they do not have a license. But they do have the technical expertise and Gen Z’s attention.

Neobanks with their technological expertise & Conventional banks with years of experience can together bridge the existing customer experience gap in the banking industry. Niyo, Jupiter, Razorpay have partnered with the traditional banks to deliver a seamless digital banking experience for their customers. According to the Redseer Strategy Consulting report, partnership profits both, giving neobanks a strong position and traditional banks access to young, tech-savvy customers. Recently, Visa and AI-driven neo bank OneBanc Technologies teamed up to launch the first magnetic-strip-free debit and credit cards in India. More than 300,000 new accounts with neo-banking partners have been launched by Federal Bank. 

In the end, it’s all about creating the best customer experience. And working in silos might turn out to be a disaster for both parties. Healthy cooperation may definitely help win customers. 

Cancel

Knowledge thats worth delivered in your inbox

Implementing a Clean Architecture with Nest.JS

4 minutes read

This article is for enthusiasts who strive to write clean, scalable, and more importantly refactorable code. It will give an idea about how Nest.JS can help us write clean code and what underlying architecture it uses.

Implementing a clean architecture with Nest.JS will require us to first comprehend what this framework is and how it works.

What is Nest.JS?

Nest or Nest.JS is a framework for building efficient, scalable Node.js applications (server-side) built with TypeScript. It uses Express or Fastify and allows a level of abstraction to enable developers to use an ample amount of modules (third-party) within their code.

Let’s dig deeper into what is this clean architecture all about. 

Well, you all might have used or at least heard of MVC architecture. MVC stands for Model, View, Controller. The idea behind this is to separate our project structure into 3 different sections.

1. Model: It will contain the Object file which maps with Relation/Documents in the DB.

2. Controller: It is the request handler and is responsible for the business logic implementation and all the data manipulation.

3. View: This part will contain files that are concerned with the displaying of the data, either HTML files or some templating engine files.

To create a model, we need some kind of ORM/ODM tool/module/library to build it with. For instance, if you directly use the module, let’s say ‘sequelize’, and then use the same to implement login in your controller and make your core business logic dependent upon the ‘sequelize’. Now, down the line, let’s say after 10 years, there is a better tool in the market that you want to use, but as soon as you replace sequelize with it, you will have to change lots of lines of code to prevent it from breaking. Also, you’ll have to test all the features once again to check if it’s deployed successfully or not which may waste valuable time and resource as well. To overcome this challenge, we can use the last principle of SOLID which is the Dependency Inversion Principle, and a technique called dependency injection to avoid such a mess.

Still confused? Let me explain in detail.

So, what Dependency Inversion Principle says in simple words is, you create your core business logic and then build dependency around it. In other words, free your core logic and business rules from any kind of dependency and modify the outer layers in such a way that they are dependent on your core logic instead of your logic dependent on this. That’s what clean architecture is. It takes out the dependency from your core business logic and builds the system around it in such a way that they seem to be dependent on it rather than it being dependent on them.

Let’s try to understand this with the below diagram.

Source: Clean Architecture Cone 

You can see that we have divided our architecture into 4 layers:

1. Entities: At its core, entities are the models(Enterprise rules) that define your enterprise rules and tell what the application is about. This layer will hardly change over time and is usually abstract and not accessible directly. For eg., every application has a ‘user’. What all fields the user should store, their types, and relations with other entities will comprise an Entity.

2. Use cases: It tells us how can we implement the enterprise rules. Let’s take the example of the user again. Now we know what data to be operated upon, the use case tells us how to operate upon this data, like the user will have a password that needs to be encrypted, the user needs to be created, and the password can be changed at any given point of time, etc.

3. Controllers/Gateways: These are channels that help us to implement the use cases using external tools and libraries using dependency injection.

4. External Tools: All the tools and libraries we use to build our logic will come under this layer eg. ORM, Emailer, Encryption, etc.

The tools we use will be depending upon how we channel them to use cases and in turn, use cases will depend upon the entities which is the core of our business. This way we have inverted the dependency from outwards to inwards. That’s what the Dependency Inversion Principal of SOLID implies.

Okay, by now, you got the gist of Nest.JS and understood how clean architecture works. Now the question arises, how these two are related?  

Let’s try to understand what are the 3 building blocks of Nest.JS and what each of them does.

  1. Modules: Nest.JS is structured in such a way that we can treat each feature as a module. For eg., anything which is linked with the User such as models, controllers, DTOs, interfaces, etc., can be separated as a module. A module has a controller and a bunch of providers which are injectible functionalities like services, orm, emailer, etc.
  1. Controllers: Controllers in Nest.JS are interfaces between the network and your logic. They are used to handle requests and return responses to the client side of the application (for example, call to the API).
  1. Providers (Services): Providers are injectable services/functionalities which we can inject into controllers and other providers to provide flexibility and extra functionality. They abstract any form of complexity and logic.

To summarize,

  • We have controllers that act as interfaces (3rd layer of clean architecture)
  • We have providers which can be injected to provide functionality (4th layer of clean architecture: DB, Devices, etc.)
  • We can also create services and repositories to define our use case (2nd Layer)
  • We can define our entities using DB providers (1st Layer)

Conclusion:

Nest.JS is a powerful Node.JS framework and the most well-known typescript available today. Now that you’ve got the lowdown on this framework, you must be wondering if we can use it to build a project structure with a clean architecture. Well, the answer is -Yes! Absolutely. How? I’ll explain in the next series of this article. 

Till then, Stay tuned!

About the Author:

Junaid Bhat is currently working as a Tech Lead in Mantra Labs. He is a tech enthusiast striving to become a better engineer every day by following industry standards and aligned towards a more structured approach to problem-solving. 


Read our latest blog: Golang-Beego Framework and its Applications

Cancel

Knowledge thats worth delivered in your inbox

Loading More Posts ...
Go Top