[Paper Review] Microservices: Migration of a Mission Critical System

Nicola Dragoni, Schahram Dustdar+2 more|arXiv (Cornell University)|Jan 1, 2017

Software System Performance and Reliability5 references31 citations

TL;DR

This paper presents a real-world case study of migrating Danske Bank's mission-critical FX Core system from a monolithic to a microservices architecture, demonstrating significant improvements in scalability, maintainability, and operational flexibility through automation, service discovery, orchestration, and loose coupling. The migration resolved long-standing monolithic issues such as tight coupling, complex deployments, and lack of visibility, resulting in a more resilient and scalable financial system.

ABSTRACT

The microservices paradigm aims at changing the way in which software is perceived, conceived and designed. One of the foundational characteristics of this new promising paradigm, compared for instance to monolithic architectures, is scalability. In this paper, we present a real world case study in order to demonstrate how scalability is positively affected by re-implementing a monolithic architecture into microservices. The case study is based on the FX Core system, a mission critical system of Danske Bank, the largest bank in Denmark and one of the leading financial institutions in Northern Europe.

Motivation & Objective

• To investigate the challenges and benefits of migrating a mission-critical financial system from monolithic to microservices architecture.
• To analyze how microservices improve system scalability in real-world production environments.
• To identify key technical enablers—such as automation, orchestration, and service discovery—that unlock microservices' scalability potential.
• To demonstrate how architectural transformation resolves long-standing monolithic anti-patterns like coupling, deployment complexity, and lack of monitoring.
• To provide a practical, industry-grade example of microservices adoption in a high-stakes financial institution.

Proposed method

• Conducted a detailed case study of the FX Core system at Danske Bank, comparing its legacy monolithic and new microservice architectures.
• Identified and implemented core microservices principles: bounded context, fine-grained service size, and operational independence.
• Employed containerization via Docker and orchestration with Kubernetes to manage service deployment, scaling, and lifecycle.
• Integrated service discovery (e.g., Consul) and load balancing to enable dynamic, resilient communication between services.
• Established centralized logging (LoggingService, Elasticsearch, Kibana) and monitoring (MonitoringService, Icinga, cAdvisor) for system-wide observability.
• Adopted a polyglot architecture allowing independent technology choices per service, reducing vendor lock-in.

Experimental results

Research questions

• RQ1 How does migrating a mission-critical monolithic system to microservices impact system scalability?
• RQ2 What technical enablers are essential for unlocking the full scalability potential of microservices in production?
• RQ3 To what extent do microservices resolve common anti-patterns found in monolithic financial systems?
• RQ4 How does the new architecture improve deployment, monitoring, and operational control?
• RQ5 What are the practical challenges and trade-offs in real-world microservices migration for enterprise systems?

Key findings

• The microservices architecture significantly improved system scalability by enabling independent scaling of individual services based on workload.
• The migration resolved monolithic anti-patterns such as large, tightly-coupled components, shared components, and complex deployments.
• Service independence and containerization allowed for zero-downtime deployments and reduced dependency conflicts.
• Centralized logging and monitoring provided a unified system status overview, enabling proactive detection of issues.
• The use of message-based choreography via RabbitMQ reduced coupling between services and improved fault tolerance.
• The system achieved greater technological flexibility through a polyglot architecture, reducing dependence on legacy platforms like .NET and MS SQL.