Sanil Basutkar
Author
The most challenging problems aren't technical; they're about bridging the gap between what users need and what existing systems can deliver. When we started building our travel insurance platform, the problem seemed straightforward: make travel insurance instant and seamless during booking flows.
However, as we delved deeper, we uncovered the true challenges that were holding India's travel insurance back in the analog age.
The core issue wasn't just the slow manual processes, but the reliability nightmare of depending on multiple external systems:
The fundamental challenge that we encountered was - How do you promise real-time insurance when your downstream dependencies can sometimes fail?
Before building our platform, we witnessed what happened when travel booking systems tried to integrate directly with insurance APIs:
Scenario 1: User books ticket → Travel platform calls insurance API → Insurance API times out → Entire booking flow fails → User abandons purchase → Lost revenue for everyone
Or worse, the API fails silently: Booking completes → Insurance API fails silently → User thinks they're insured → While they're not insured → Disaster occurs when they actually need coverage as there is no record of their insurance
Traditional solutions tried to solve this with:
We found that none of these approaches could deliver the real-time, guaranteed reliability that modern travel platforms needed.
After working with various programming languages, we needed a language that could handle our specific challenges. Go's concurrency model was perfect for this:
We needed to call multiple insurance providers simultaneously, handle thousands of concurrent bookings, and process async operations without blocking the main request flow. Go's goroutines made this simple:
// Instead of sequential calls (6000-8000ms total)
Call Insurer A → Wait 3000ms
Call Insurer B → Wait 3000ms
Call Insurer C → Wait 2000ms
// Concurrent calls with Go (1000-1200ms total)
Launch 3 goroutines simultaneously
Return first successful response
With 100K+ monthly bookings, we needed predictable memory usage. Go's garbage collector and small goroutine overhead (2KB initial stack) meant we could handle thousands of concurrent requests without memory bloat.
Go's single binary deployment was refreshing. No dependency conflicts, no runtime version issues, we could just copy a binary and run it.
Our Complete Tech Stack: We Tested These To Survive Unreliable Dependencies
Every component in our stack was chosen to solve specific reliability and scalability challenges:
API Gateway: Built-in DDoS protection, request validation, and rate limiting Authorization Layer: JWT-based token validation, partner authentication, and request signing verification ALB: Health checks and automatic failover between EKS instances via target groups Target Groups: Intelligent routing and health monitoring of backend instances Private EKS: No direct internet access = reduced attack surface
This setup gives us multiple layers of protection and automatic failover. When one EKS instance fails, ALB routes traffic to healthy instances within milliseconds.
For insurance, data consistency isn't optional. PostgreSQL's ACID properties ensure that:
While PostgreSQL handles our critical financial data, DynamoDB manages:
The key insight: Use the right database for each use case rather than forcing everything into one solution.
This is where we solved the "unreliable dependencies" problem. Instead of making users wait for slow downstream APIs, we implemented an async pattern:
This async pattern creates a self-healing system:
Result: Zero user impact, zero lost policies
A Deep Dive Into Our System: The Adapter Pattern
The heart of our system is an adapter-based architecture that decouples our business logic from the chaos of external APIs:
Instead of tightly coupling our code to specific insurer APIs, we created a common interface:
type InsuranceProvider interface {
CreatePolicy(request PolicyRequest) (*PolicyResponse, error)
GetPolicyStatus(policyID string) (*PolicyStatus, error)
CancelPolicy(policyID string) error
}
Each insurer implements this interface differently:
But our core business logic sees them all the same way.
// Business rules for provider selection
if req.TravelType == "DOMESTIC" && req.Amount < 10000 {
return findProvider("PREFERRED") // Best rates for domestic travel
}
if req.Priority == "INSTANT" {
return findProvider("FASTEST") // Fastest response times
}
// Default: Round-robin for load distribution
return providers[time.Now().Unix() % len(providers)]
This makes it easy to:
Our platform promises policy creation within 1200ms. Here's how we achieve this consistently:
// Launch multiple goroutines for different insurers
resultChan := make(chan *PolicyResponse, 3)
errorChan := make(chan error, 3)
go callInsurer1(request, resultChan, errorChan)
go callInsurer2(request, resultChan, errorChan)
go callInsurer3(request, resultChan, errorChan)
// Return first successful response
select {
case response := <-resultChan:
return response // Success within 1200ms!
case <-time.After(1200 * time.Millisecond):
return timeout_error
}
We built comprehensive monitoring without relying on external services:
Our system automatically attempts to fix common issues:
type CircuitBreaker struct {
failures int
lastFailure time.Time
state string // "closed", "open", "half-open"
}
func (cb *CircuitBreaker) Call(operation func() error) error {
if cb.state == "open" {
if time.Since(cb.lastFailure) > 30*time.Second {
cb.state = "half-open" // Try again
} else {
return errors.New("circuit breaker open")
}
}
err := operation()
if err != nil {
cb.failures++
cb.lastFailure = time.Now()
if cb.failures >= 5 {
cb.state = "open" // Stop trying
}
} else {
cb.failures = 0
cb.state = "closed" // All good
}
return err
}
Our system handles various failure scenarios automatically:
Impact: Zero user-facing errors, zero lost policies
During peak booking times (holidays, festivals), our system automatically scales:
Peak Traffic Detected: 3x normal volume → Auto-scaling triggers additional EKS instances → Load balancer distributes traffic across target groups to new instances → Message Broker queues absorb burst traffic → Processing continues at steady rate → No requests timeout or get lost
This is what we learnt by building systems for the real world:
Debugging issues across multiple insurers and async processing was challenging. Distributed tracing should have been a day-one requirement.
Our initial metrics were too high-level. Per-partner, per-insurer, and per-endpoint granularity was crucial for optimization.
Our initial load tests used mock APIs that were far more reliable than real insurer APIs. Load testing should simulate real-world failures.
After 12 months in production:
Our adapter-based architecture positions us for expansion:
Technical Roadmap
Building a real-time insurance platform taught us that reliability isn't about perfect components, but about graceful handling of imperfect ones. Our success came from:
The Indian travel insurance market was ready for disruption, not because of technology limitations, but because of integration and reliability challenges. By solving the fundamental problem of unreliable dependencies, we created a platform that processes 100,000+ monthly bookings with 99.9% uptime.
Engineering isn't about using the latest frameworks or architectures. It's about understanding real-world constraints and building systems that work reliably despite those constraints. This platform represents everything we've learned about creating software that actually solves problems for real people. The 700,000+ travelers who got instant insurance coverage are proof that thoughtful engineering can transform the entire industry.
As India's digital economy grows, we anticipate that the principles we've applied here — reliability, scalability, and self-healing design, will become even more critical for the next generation of fintech platforms.
At Coverbiz, we provide a wide range of plans, including health, marine, directors and officers insurance, commercial general liability, and commercial crime insurance. We offer complete customisation for each policy based on your coverage needs and budget.
You can contact our in-house IRDAI-licensed insurance experts for free and book a consultation call to get all your insurance doubts clarified. We help you to identify the best policy based on your business needs and annual objectives. With Coverbiz, you can compare plans based on coverage limits, exclusions, premiums, and claim settlement ratios. Our trained advisors can help you evaluate and pick the best match for your needs.
Personal insurance covers your individual and family insurance needs against health risks, accidents, or property damage. Business insurance protects organizations of any size from financial losses arising from events such as employee injury, property loss, or liability claims.
To make a claim, you can contact our claims department through our 24/7 hotline, submit a claim online through your customer portal, or visit any of our branch offices. You'll need to provide relevant documentation and details about the incident that led to your claim.
The claim process typically takes 5-15 business days from the time we receive all required documentation. Simple claims may be processed faster, while complex claims requiring investigation may take longer. We'll always keep you updated throughout the process.
Each policy has its own exclusions. For example, in health insurance, the common claim exclusions include pre-existing conditions (if not declared), self-harm, negligence, or health loss due to addictions. Always review your policy wording to know the exact list.
Yes, you can cancel your policy only if you’re within the free-look period, which is usually 15 days from the date of issuance. After that, you may face applicable deductions based on policy terms.
Yes. Even with strong safety measures and ample savings, businesses are always exposed to risks like natural disasters, data breaches, or third-party claims. Business insurance acts absorb all such losses to let the business continue without any disruption.
Absolutely, you can. Coverbiz offers group health insurance for your entire team at a nominal premium. You get complete health coverage as well as accident coverage for teams of any size with the Coverbiz employee wellness plan. You can also extend your employee health insurance to a family floater plan with added benefits.
Yes. As per the new tax amendment by the 56th GST Council, you can now opt to purchase health insurance without paying any tax. There is a complete tax exemption for all health and life insurance policies from September 22, 2025, onwards.
Contact us for any queries related to business insurance, coverages, plans and policies. Our insurance experts will assist you.
Before choosing a business health insurance for gig workers, check disability and maternity coverage, CSR ratio and waiting period. Know how to select the best plan in easy steps.
Claim rejection happens due to incorrect details while claim repudiation is when the insurer refuses to process a claim due to suspicion of fraud. Find out how to avoid claim rejection in easy steps.
An IEC code verification is a one-time license that businesses need to have smooth exports and imports. Learn the process of online application step-by-step.
Comprehensive liability and asset insurance tailored for businesses of all sizes. One partner, complete coverage.
