Transforming a Monolithic Health Platform into a Multi-Tenant SaaS Solution

A national health services organization serving multiple US state programs needed to evolve its proven but monolithic Java platform into a true multi-tenant SaaS solution. We are leading the transformation — decomposing the monolith into Spring Boot microservices, implementing tenant isolation on AWS, modernizing the Angular frontend, and deploying custom AI agents to accelerate development velocity by 3×.

The Challenge

The organization had a successful member portal serving multiple states, but each new state required months of custom development, separate infrastructure, and dedicated maintenance. The existing Java monolith had grown to over 800K lines of code with tightly coupled state-specific logic. Deployments were monthly, risky, and required coordinated downtime across all states. Development teams were siloed by state, duplicating effort and unable to share improvements. The cost of adding each new tenant (state) was nearly the same as the first — there were no economies of scale. Leadership wanted to serve 15+ states within 3 years, which was impossible with the current architecture and velocity.

Our Approach

Architecture & Domain Decomposition — Weeks 1–4

Mapped the monolith's bounded contexts, identified service boundaries, and designed a multi-tenant microservices architecture with shared infrastructure and tenant-isolated data.

• Domain-driven design workshops to identify 12 bounded contexts
• Tenant isolation strategy: shared compute, isolated data (schema-per-tenant on Aurora)
• Event-driven architecture design with Kafka for cross-service communication
• API gateway and tenant routing patterns for Angular frontend

Microservices Extraction & Multi-Tenancy — Weeks 5–12

Incrementally extracted services from the monolith using the strangler fig pattern. Implemented tenant context propagation, data isolation, and shared service foundations.

• Strangler fig migration: routing traffic incrementally to new services
• Spring Boot microservices with tenant-aware repositories and security
• Schema-per-tenant on Amazon Aurora with automated provisioning
• Shared libraries for auth, audit logging, tenant resolution, and observability

CI/CD, Infrastructure & DevEx — Weeks 13–16

Built Kubernetes-based deployment infrastructure on EKS with Terraform, automated CI/CD pipelines, and developer tooling to support independent service deployment.

• EKS cluster with namespace-per-service isolation
• Terraform modules for tenant infrastructure provisioning
• GitHub Actions pipelines: lint, test, build, deploy per service
• Feature flags for tenant-specific capability rollout without branching

AI-Assisted Development & Acceleration — Weeks 17–20

Deployed AI coding assistants and custom agents to accelerate development — AWS Kiro for agentic development workflows, GitHub Copilot for inline code generation, and custom agents tailored to the codebase for migration assistance and test automation.

• AWS Kiro for spec-driven development, automated task execution, and codebase-aware implementation
• GitHub Copilot for inline code completion, boilerplate reduction, and pattern suggestion
• Custom AI agent trained on internal coding standards for migration assistance
• Automated test generation achieving 80%+ coverage on migrated services
• AI-powered documentation generation from code and API contracts
• Developer onboarding accelerated with codebase Q&A workflows

Outcomes

Multi-Tenant Architecture

12 microservices extracted and running on EKS. New tenant (state) onboarding reduced from 6 months of custom development to 2 weeks of configuration — unlocking the path to 15+ states.

Deployment Velocity

Deployment frequency moved from monthly coordinated releases to daily independent service deployments. Lead time for changes dropped from 4 weeks to 3 days.

Development Acceleration

AWS Kiro and GitHub Copilot combined with custom agents reduced boilerplate development time by 60%. Spec-driven workflows, automated test generation, and migration assistance increased overall team velocity by 3×.

Cost Efficiency

Shared multi-tenant infrastructure reduced per-tenant hosting cost by 35%. Automated provisioning eliminated the dedicated infrastructure setup previously required for each state.

Team Autonomy

Development teams now own independent services and deploy without cross-team coordination. State-specific logic is configuration, not code — eliminating the siloed development model.