Try : Insurtech, Application Development










Dev Ops(2)

Enterprise Solution(22)




Augmented Reality(17)

Customer Journey(12)


User Experience(34)

AI in Insurance(31)


Product Innovation(37)





Telehealth Care(1)


Artificial Intelligence(109)



Cognitive Computing(7)

Computer Vision(8)

Data Science(14)


Intelligent Automation(26)

Machine Learning(46)

Natural Language Processing(13)

Can Distributed Ledgers Accelerate Insurance Workflows?

The years 2018-19 are the banner years for the US$ 5.17 trillion global insurance sector. However double-booking, counterfeiting, and premium diversions through unlicensed brokers still throb insurance companies. And one of the prime reasons for such unethical activities is the lack of tight coupling between stakeholders. A simple solution to these challenges is distributed ledgers- a contemporary technology that ensures transparency. Distributed ledger technology in insurance can create a collaborative environment for handling information, minimizing instances of fraudulent activities. 

How Can Distributed Ledgers Accelerate Insurance Workflows?

Where most insurtech startups and small insurers are looking for “insurance-in-a-box” technology, big players demand bespoke technology to develop distinct capabilities for customer convenience and manage their enterprise workflows. Fortunately, distributed ledger technology solves a major chunk of this problem. 

For startups and small to medium size insurtech firms, cloud-based, customizable workflow management products can simplify the processes and create a collaborative work environment. Large enterprises can, of course, afford time and investment for tailor-made technologies suitable for their overall business requirements.

#Smart Contracts

Smart contracts can automatically determine whether to transfer an asset to the nominee or back to the source, or a combination of both. It does not necessarily create a contract or legal act, but can sure validate a condition. For example, Ethereum provides a prominent smart contract framework. 

Smart contracts allow credible transactions with or without involving third parties (oracles).

For example, Etherisc uses smart contracts concepts for building insurance products. The fundamentals used for Etherisc’s insuring flight delays product is applicable for insurance products like crop insurance, flood, earthquake, etc.

#Claims Management

Cifas reports a 27% rise in false insurance claims across the UK in the past year. Moreover, insurers identify 1 in every 30 claims as fraudulent. Organizations can track records better with distributed ledgers minimizing the illicit instances. 

Blockchain technology allows for automated real-time data collection and analysis. BCG expects Property and Casualty (P&C) insurance has the potential of processing claims up to 3x faster and 5x cheaper than traditional processes. 

It can also enhance customer experience by removing indirections due to various touchpoints between him and the claim settlement manager. Distributed ledgers can overall benefit processing time, automating payments, eliminating trust issues, and fraud reduction.

Traditional Insurance Model vs Distributed Ledger Insurance Model: Distributed Ledger Technology in Insurance


Reinsurance (passing a whole or part of insurance liabilities to another company) will simplify the sharing of data like bordereau and claims databases. For the insurance companies not preferring to share their client’s data, access rights can be customized in distributed ledgers.

According to PWC research, the reinsurance industry can save up to $10B by increasing operational efficiencies through distributed ledgers.


“A shared, distributed ledger lends itself to this need for exchanging transparent, trustworthy data in a standard format in real-time.” 

Stefan Schrijnen: Director, Insurance, EY

Having accurate real-world data can help underwriters reduce paperwork and measure the assets and risks effectively.

Insurwave, a blockchain-enabled insurance platform uses a distributed database with secure access for insuring shipments across the world. Maersk, the world’s leading shipping and logistics company have partnered with Insurwave for insurance renewal of its fleet of 800 container ships. 

In the words of Lars Henneberg, Head of Risk Management at A.P. Moller – Maersk. “A simple dashboard gives us a live overview of how our assets are insured, and our brokers and insurers have access to the same overview. If the location, cargo, or other data about our ships changes, everyone is notified — no delays, no paperwork, no mistakes.” 

#Product Design using Distributed Ledger Technology in Insurance

Instead of all-encompassing insurance policies, consumers look for short, custom-built policies that satisfy their immediate needs. Therefore, to stay competitive, insurance companies (and even e-commerce startups) need to consistently build new and relevant insurance products. Expanding features or building new products on the same fundamentals can be effectively realized with strong and transparent ledgers.

AXA’s smart contract product Fizzy is a next-generation Parametric Insurer, which uses transparency as its USP. It provides travel insurance on flight delays and cancellations. The claims displayed on the website are stored in a blockchain and no one can change the terms after purchase. User can buy the insurance online. When the flight is delayed or canceled, the public databases of plane status information automatically triggers the insurance holder’s compensation. The event confirmation executes and closes the claim process instantly.

Precautions to Take With Distributed Ledgers in Insurance

  1. Enterprises should be cautious about sharing access rights on distributed ledgers.
  2. Blockchain transactions are irreversible, therefore every click from an authorized user should be mindful.
  3. Instead of mimicking a trend, insurance companies can deploy the distributed ledger technology to best suit their business requirements.


MarketsandMarkets expects blockchain technology’s share in the insurance market to reach $1.4 billion by 2023. 

The insurance industry has already deployed distributed ledger components for insuring flight delays, lost baggage claims, and is expanding to shipping, health, and consumer durables domains. 

The future can also witness blockchain, AI, drones, and robotics disrupting the insurance industry together.


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)


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


Knowledge thats worth delivered in your inbox

Loading More Posts ...
Go Top