INTERNAL2025

Monolith to Microservices Migration

At Rampwin, the monolith had become the org-level risk: deployment coupling meant any release could affect unrelated domains, a single bad query could degrade the entire platform, and a service failure could cascade everywhere. I led the migration. Started with event storming to map domain boundaries, no code changes until the boundaries were agreed and service contracts were defined. Used strangler fig for incremental extraction with feature-flag traffic routing. Built the observability layer in parallel so failure modes were tracked from day one, not discovered reactively. Result: MTTR dropped 28%, deployment frequency increased across teams, and cross-domain incidents became structurally impossible.

$ Architecture

→Event storming workshop output: 6 bounded contexts identified and agreed before any code was touched, domain boundaries as first-class design artifacts
→Strangler fig extraction: new service traffic routed via feature flags at the Nginx layer; monolith kept live and functional until consumer migration was verified complete
→Kafka event bus as the inter-service communication fabric, async, decoupled, replay-capable; services produce and consume domain events without direct coupling
→Distributed sagas for cross-service transactions (checkout, order lifecycle), replacing monolith ACID guarantees with explicit eventual consistency and compensating actions
→Per-service MongoDB collections with no shared schema, data ownership enforced at the persistence layer, not just the API layer
→Istio service mesh for mTLS between services, distributed tracing via Jaeger, and controlled traffic shaping during phased cutover

$ Tech Stack

JavaSpring BootMongoDBKafkaDockerKubernetesIstio

$ Outcomes

→MTTR reduced 28%, failures in one bounded context are now structurally contained and cannot cascade

→Independent deployment pipelines per service: teams release without coordination overhead or shared deployment windows

→API contract testing (Pact) enforced in CI, breaking changes caught before staging, on every commit

→Distributed saga orchestration for checkout and order workflows with full compensating transaction support and idempotent retry

→Per-service observability from day one: structured logs, distributed traces, and Prometheus metrics built into the service template

→MongoDB performance optimization under high-write load: compound index design, write concern tuning, and read replica routing