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)

How Machine Vision can Revolutionize Motor Insurance

3 minutes, 49 seconds read

The motor insurance market in India is approximately Rs 70,000 crore in terms of Gross Written Premiums. With newer and stricter regulations more and more people are buying motor insurance. However, while motor insurance, in general, has grown by 16% over the last year, the new digital insurers in the marketplace have seen their premiums increase by 4X-6X. 

This underlines a shift in the way customers choose to buy motor insurance – from the convenience of their smartphone or computer, instantly. There is no reason to think that they would not want to settle an insurance claim in the same convenient manner. Fortunately, machine vision technology solves claims settlement challenges to a great extent.

Current Claims Process

Let us have a quick look at the current claim settlement process for motor insurance. Once the accident occurs, the insured has to follow the following steps:

  1. The insured informs the insurance company about the accident. Subsequently, the insured files a physical claim along with the required documents such as RC, DL, insurance policy, bills, receipts, etc.
  2. A surveyor gets assigned by the insurance company to examine the damaged vehicle. 
  3. The surveyor ascertains the reason and the extent of the loss. After this, the insurer sends an approval/rejection of the claim/amount.

The above process is not only time consuming and stressful for the insured but also expensive for the insurer due to physical inspection and other manual checks and balances. The higher cost of processing the claim makes business less profitable to the insurer. The inconvenience and long wait make the product less desirable to the customer.

As more and more people buy motor insurance online, the customer expectation from the claim settlement process is changing as well. Customers now expect a seamless digital claim settlement process preferably in a matter of hours if not minutes, instead of the present industry standard of several days.

A Machine Vision Solution to Instant Claims Processing: FlowMagic

We at FlowMagic set out to solve this problem both for the insured and insurer using the power of artificial intelligence. We have used machine vision to eliminate the need for the surveyor in all but the most complex cases. 

Using machine vision, we can process a car image and identify not only the damaged parts but also the severity of damage to those parts and whether it requires repair or a replacement. We have further analyzed repair cost data and images from tens of thousands of accident cases to build an Artificial Intelligence Costing Model that can estimate the cost of repairing any part just by looking at its photograph. All this means that the insurer doesn’t need the surveyor and other manual checks in most cases and the customer can submit a claim from the convenience of his smartphone and get an approval decision within minutes.

New Claims Settlement Process with FlowMagic

  1. After the accident, the customer clicks photographs of damaged parts of the car and uploads them on the app along with a photo of DL/RC.
  2. The AI model verifies the DL/RC information and estimates the extent of damage to the car and whether the damaged parts need to be replaced or repaired. The model further calculates the cost of repair and/or replacement and informs the customer/insurance company.
  3. Based on the outcome of the DL/RC verification and the repair estimate the claim is either auto-approved in minutes or forwarded to a claims adjuster for review.

All the stakeholders in the insurance value chain can use our solution and benefit from it.

Insurance Company: By integrating this solution with mobile applications, Insurance companies can get quick claims intimations and a reasonable estimate of the repair cost. The damage severity analysis also helps the insurance company negotiate with the garage on whether a part needs repair or replacement.

Service Center or Garage: Multi-brand garages or service centers can quickly assess the level of damage to any car brought to them through machine vision-based FlowMagic. Accordingly, they can send a quick quotation to the insurance companies. The insurance companies can trust this quotation as it is generated by a robust AI model.

End Customer: An end customer can also use our free mobile application to get a repair estimate. This can be a starting point for an informed negotiation with a garage.

To learn more about how FlowMagic can transform the way you settle your motor insurance claims or discuss your broader AI goals, please get in touch with us at hello@mantralabsglobal.com 

Also read – How AI can settle insurance claims in less than 5 minutes!

About author: Himanshu Saraf is a Capital Markets Director at Mantra Labs. He also leads Artificial Intelligence (AI) and Machine Learning initiatives in the company.

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