New BlogDistributed tracing without code changes using eBPF and OpenTelemetryRead the post
Skip to main content

Case Study

Hearzap's Cloud-Native Transformation: From Monolithic VMs to a Kubernetes Platform on GKE


Hearzap's platform powers hearing tests, audiologist consultations, device sales, and after-sales care across hundreds of centres in India. The business had outgrown the infrastructure underneath it. Their platform was a monolith running on bare virtual machines. That architecture worked at a smaller scale, but it had started to cap how fast the team could ship and how reliably the platform stayed up.

CloudRaft worked with Hearzap to rebuild that foundation, an end-to-end infrastructure and data-platform modernization. We migrated the platform to a cloud-native Kubernetes architecture on Google Cloud, decomposed the monolith into independent services, and put a GitOps delivery pipeline and zero-trust security model around it. This case study covers how the migration was approached and what changed for the business.

About the client

Hearzap is an Indian digital hearing-care company offering hearing assessments, audiologist consultations, and hearing aids through a network of clinics, a retail presence, and an online platform. In 2026 it acquired Amplifon India's hearing-healthcare business, growing to more than 400 centres nationwide. A platform that serves that many locations, plus the customers booking tests and buying devices online, needs infrastructure that scales with demand and stays available during business hours.

Business impact

Deployments

Minutes of automated GitOps sync

from hours of manual VM work

Availability

Multi-zone high availability

from single points of failure

Scaling

Automatic horizontal autoscaling

from manual vertical sizing

Security posture

Zero-trust + Workload Identity

from ad hoc secrets and access

Operations

GitOps automation with self-healing

from manual VM management

The challenge

As the business scaled, the old monolith-on-VMs model created problems that compounded on each other:

  • No autoscaling. Capacity was static, so peak hours degraded while idle hours were paid for in full.
  • Single points of failure. Each component ran on one VM, with no redundancy or automatic recovery.
  • Manual, disruptive deployments. Every release meant downtime and hours of manual work.
  • Configuration drift. Staging and production drifted apart, with no single source of truth.
  • Security gaps. Secrets, TLS, and access controls were managed by hand and had grown ad hoc.
  • Operational overhead. The team spent more time running infrastructure than building product.

One Kubernetes platform to replace the VM fleet

We migrated Hearzap from monolithic VMs to a cloud-native Kubernetes architecture on Google Cloud, built so that the platform scales with demand, recovers from failures on its own, and is deployed entirely from Git.

Before and after a monolith-to-Kubernetes migration: a monolith on single VMs migrated to a multi-zone Kubernetes platform with separate autoscaling pools for application and data workloads, GitOps-based delivery, and managed, highly available data services.

Figure 1. From a monolith on single VMs to a multi-zone, GitOps-driven Kubernetes platform.

A resilient foundation

The platform runs on a managed Kubernetes cluster spread across multiple availability zones, so the loss of a single zone does not take it down. Application and data workloads run in separate autoscaling pools, so each scales on its own signal and neither starves the other. The whole environment is defined as code, so it is reproducible and reviewable rather than living in the state of a running VM.

Managed platform services

Rather than hand-roll stateful systems, we run the platform's databases, message queue, and cache as managed, self-healing services, each configured for high availability with replication and automated backups. Delivery, certificates, secrets, and observability are automated the same way, so the platform is operated by the platform rather than by people.

Decomposing the monolith

The monolith was broken into independent, separately deployable services, each able to scale on its own. Delivery runs through GitOps: every change is version-controlled and continuously reconciled to the cluster, so staging and production share one source of truth and can no longer silently drift apart. Changes are validated automatically before they reach the cluster, not after a failed deploy.

Security by default

Identity and access were rebuilt around least privilege. Every service authenticates with its own identity instead of a shared credential, access maps to the team groups the organization already uses, and the cluster's control plane is private, with administrative access brokered rather than openly exposed.

Results

The application code moved to containers; almost everything else that made the old platform slow and fragile was replaced.

Deployments
BeforeHours of manual VM work, with downtime
AfterMinutes of automated GitOps sync, zero-downtime rolling updates
Reliability
BeforeSingle VM per component, no recovery
AfterSelf-healing pods, nodes replaced automatically
Databases
BeforeSingle instance, manual recovery
AfterHighly available database clusters with replicas and automatic failover
Messaging
BeforeNo message broker
AfterReplicated message queue distributed across zones
Scaling
BeforeManual vertical resizing
AfterAutoscaling pools distributed across multiple zones
Environments
BeforeDrifted between staging and production
AfterOne shared base, overlays per environment
Secrets
BeforeNot centrally managed
AfterCentralized secret management, nothing stored in the cluster
Access
BeforeAd hoc, shared credentials
AfterPrivate cluster, brokered admin access, per-service identity

A few of the changes are worth calling out:

  • Deployments stopped being events. Rolling updates keep services available during every release, and GitOps self-heal reconciles the cluster back to the desired state automatically. A deploy is a Git merge, not a maintenance window.
  • High availability is the default, not a project. Every database cluster runs with replicas and automatic failover, the message queue is distributed across zones, and the cache runs replicated. A single pod, node, or zone failure no longer means an outage.
  • Capacity follows demand. Pools scale up for peak hours and back down off-peak, so the platform stops paying for a fleet sized for its busiest minute. Separating application and data workloads keeps the two from competing for resources.
  • The security posture changed shape. No secrets on disk and no shared cloud credentials. Every service authenticates as itself, and secrets are centralized outside the cluster.

What we would tell other teams migrating off VMs

  • Let the platform run your stateful services. Databases, message queues, and caches are the parts of a migration most likely to go wrong. Mature, operator-managed versions give you failover, backups, and replica topology as declared configuration instead of runbooks.
  • Make GitOps the source of truth from day one. Once the cluster reconciles to Git, configuration drift stops being a category of problem. Staging and production share a base, and "what's actually running" is answerable by reading a repository.
  • Separate workloads by pool. Keeping data workloads off the application pool prevents resource contention and lets each scale on its own signal, a small decision early that pays off under load.
  • Replace shared credentials with workload identity. Giving each service its own cloud identity removes an entire class of secret-handling risk and makes access auditable per service.
  • Validate your changes in CI. Automated validation catches broken or non-conformant changes before they reach the cluster, not after a failed sync.

Running a monolith that has outgrown its infrastructure?

If your platform is held back by manual deployments, single points of failure, or infrastructure that can't scale with demand, we can help you migrate to a cloud-native Kubernetes architecture without betting the business on a big-bang cutover.