Government agencies facing an increasing mandate to move from legacy mainframe systems. The solution, generative AI. Now, agencies no longer need to fear the tradeoff between migration risk and the opportunity available in the cloud. In this case study featured on the AWS Public Sector Blog, our Karsun experts share their experience accelerating modernization with AI.

This case study features Karsun Solutions’ ReDuX AI powered migration and modernization platform. It offers a compelling approach for enterprises considering mainframe migration. Sharing their experience modernizing legacy applications for one of our government customers, this case study demonstrates what happens when modern AI tools meet modern software development practices. 

Deep Insights Using Amazon Bedrock

ReDuX is designed to tackle typical obstacles in mainframe modernization, such as undocumented business rules, technical complexities, and regulatory compliance. Its approach is inspired by Karsun’s decade and a half modernizing complex enterprise systems for the federal government. ReDuX utilizes generative artificial intelligence (GenAI) powered by Amazon Bedrock to analyze and understand legacy systems. 

Using Bedrock the Karsun team accessed high-performing foundation models from leading AI companies via a single API. Building their ReDuX platform on top of the resources provided by Bedrock, our team created an AI powered toolkit for identifying and mapping the complex business rules and processes embedded within mainframe applications. This facilitates a smoother transition to modern architectures. Further, by providing a structured approach, ReDuX reduces risks associated with legacy system modernization.

Matching AI with Modern Microservices Architecture

In the case study, we share how using our AI powered platform, we enabled our government customer to migrate from monolithic mainframe systems to microservices-based architectures on AWS. This shift enhances scalability, flexibility, and maintainability of applications, aligning with modern IT strategies. 

It also allowed our team to focus on security and privacy. Recognizing the importance of enterprise-grade security and privacy, especially in government and regulated industries, the platform incorporates robust measures to protect sensitive data during and after the migration process. ​

Furthermore, migration to the cloud enables secure-by-design architecture. Using AI powered tools, like those available on the ReDuX AI platform, lets our agency customers access the benefits of the cloud while reducing migration risks. Written in a modern language, it alleviates workforce concerns and eliminates long-term maintenance issues arising from the aging, dwindling population familiar with COBOL and other outdated languages.

By demonstrating a successful implementation of generative advanced AI technologies and cloud services to migrate and modernize legacy systems, this case study from our team offers valuable insights. It presents a potential roadmap for organizations seeking to undertake similar modernization initiatives. Head over to the AWS Public Sector blog for deeper insights on AI-driven modernization and a technical breakdown of our solution.

As a software developer/solutions architect, navigating the complexities of modernizing legacy applications requires more than just adopting new technologies. It demands a deep understanding of software design patterns that ensure scalable, resilient, and maintainable solutions. Unfortunately, in the rush to modernize, crucial design patterns are often overlooked, leading to technical debt, performance bottlenecks, and security vulnerabilities. This article explores key design patterns frequently ignored by modernization teams, the reasons they are neglected, and the consequences of bypassing them. By integrating these patterns into modernization strategies, developers and architects can build robust, future-proof applications that stand the test of evolving technological landscapes.

Strangler Fig Pattern

The Strangler Fig Pattern is a gradual migration strategy where new functionality is built around the existing legacy system, slowly replacing it until the old system is entirely phased out.

• Why it’s overlooked: Modernization teams often opt for a full rewrite rather than incremental refactoring, assuming that starting from scratch will be faster and more efficient. However, this can introduce significant risks and delays.
• Real-world example: A financial institution migrating from a monolithic COBOL-based mainframe to a microservices-based architecture used the Strangler Fig Pattern. They introduced an API layer that progressively handled more transactions while legacy components were retired incrementally.
• Consequence of ignoring it: A complete system rewrite without this pattern can lead to prolonged development times, business disruptions, and increased failure risks due to untested new implementations.
• When to use: Use this pattern when modernizing large, complex legacy applications that cannot afford extended downtime or complete overhauls at once.

Saga Pattern

The Saga Pattern manages distributed transactions by breaking them into a series of smaller, compensating transactions.

• Why it’s overlooked: Modernization teams often assume eventual consistency is automatically handled by microservices frameworks, neglecting explicit transactional workflows. Implementing sagas can be challenging due to the need for handling failures and maintaining consistency. Teams may opt for simpler orchestration mechanisms without considering the potential for distributed transaction failures.
• A real-world example: An online travel booking system had issues where partial failures left customers with incomplete reservations (e.g., flights booked but hotels not confirmed). Implementing the Saga Pattern ensured rollback mechanisms were in place, maintaining data consistency across services. 
• Consequence of ignoring it: Without the Saga Pattern, distributed systems suffer from data inconsistencies, orphaned transactions, and poor user experience. Distributed transactions can lead to inconsistencies if not handled properly. Failures in one service can impact the entire transaction.
• When to use: Use this pattern when dealing with distributed transactions involving multiple services that must maintain consistency and systems with complex business transactions that span multiple services.

Sidecar Pattern

The Sidecar Pattern runs auxiliary services in separate containers alongside main application services, enabling functionalities like logging, monitoring, and security without modifying the core application.

• Why It’s Overlooked: Modernization teams may prioritize core service development and neglect auxiliary concerns, leading to bloated application code.
• Real-World Example: A fintech company used the Sidecar Pattern to deploy a separate logging and monitoring service alongside each microservice, simplifying debugging and performance tracking.
• Consequence of Ignoring It: Neglecting this pattern leads to tightly coupled services, making maintenance difficult and increasing the complexity of scaling and updating auxiliary functions.
• When to Use: Use this pattern when microservices require independent functionalities like logging, monitoring, or security without modifying the core service logic.

Circuit Breaker Pattern

The Circuit Breaker Pattern prevents a system from continuously making requests to a failing service, reducing unnecessary load and enabling faster recovery.

• Why it’s overlooked: Modernization teams often assume cloud-native platforms handle failure gracefully, ignoring the need for explicit fault tolerance mechanisms.
• Real-world example: Netflix employs the Circuit Breaker Pattern to maintain high availability in its microservices architecture. If a particular service fails repeatedly, the circuit breaker trips and prevents further calls until recovery.
• Consequence of ignoring it: Without circuit breakers, cascading failures can occur, where a single failing microservice can bring down an entire system due to unhandled retries and excessive load.
• When to use: Use this pattern in distributed systems where service failures must be isolated to prevent widespread outages.

Bulkhead Pattern

The Bulkhead Pattern isolates different components or services so that failures in one do not impact the others.

• Why it’s overlooked: Many teams focus on horizontal scaling but neglect to compartmentalize workloads, making services susceptible to systemic failures.
• Real-world example: In e-commerce platforms, checkout, inventory, and recommendation services can be isolated using bulkheads to ensure that failure in one does not affect the others.
• Consequence of ignoring it: Ignoring this pattern can lead to entire systems going down due to a single point of failure, significantly impacting user experience and revenue.
• When to use: Use this pattern in microservices architectures where services must operate independently to ensure resilience.

Event Sourcing Pattern

The Event Sourcing Pattern stores changes to an application’s state as a sequence of immutable events rather than modifying records directly.

• Why it’s overlooked: Teams often prioritize relational database models and transactional consistency, overlooking event-driven architectures that enhance auditability and scalability.
• Real-world example: Uber uses event sourcing to track rides, payments, and user interactions, ensuring that every action is recorded as an event for consistency and debugging.
• Consequence of ignoring it: Not using event sourcing can lead to data inconsistencies, loss of historical data, and difficulties in troubleshooting and replaying past transactions.
• When to use: Use this pattern in applications requiring strong audit trails, historical tracking, and event-driven state management.

CQRS (Command Query Responsibility Segregation) Pattern

CQRS pattern separates read and write operations into different models, optimizing for performance and scalability.

• Why it’s overlooked: Many teams’ default to CRUD-based architectures without considering read-heavy or write-heavy optimizations.
• Real-world example: E-commerce platforms like Amazon use CQRS to manage inventory updates separately from customer queries, ensuring high performance under heavy loads.
• Consequence of ignoring it: Ignoring CQRS can lead to database contention, performance bottlenecks, and inefficient scaling strategies.
• When to use: Use CQRS in high-performance applications where read and write workloads differ significantly.

Repository Pattern

The Repository Pattern separates the business logic from data access, providing a clean abstraction layer between application logic and database queries.

• Why It’s Overlooked: Modern ORM (Object-Relational Mapping) frameworks promise simplified data management, leading teams to believe explicit repository layers are unnecessary.
• Real-World Example: A healthcare software provider initially used direct ORM calls within service classes. As the system scaled, database logic became scattered, leading to maintenance challenges. Refactoring to use the Repository Pattern improved code organization and maintainability.
• Consequence of Ignoring It: Ignoring this pattern leads to tightly coupled code, making it harder to switch databases, optimize queries, or maintain separation of concerns.
• When to Use: Use this pattern when dealing with complex domain logic that requires a clean separation between business rules and data access.

API Gateway Pattern

The API Gateway Pattern acts as a single entry point for all client requests, routing them to appropriate backend services while handling cross-cutting concerns like authentication, logging, and rate limiting.

• Why It’s Overlooked: Teams may assume direct client-to-microservice communication is sufficient, leading to complex client logic and inefficient network calls.
• Real-World Example: A streaming service adopted an API Gateway to handle authentication, request aggregation, and traffic management across various backend services, improving performance and security.
• Consequence of Ignoring It: Without an API Gateway, microservices architectures can become fragmented, increasing security risks, inconsistent data access, and complex client-side logic.
• When to Use: Use this pattern when managing multiple microservices and requiring centralized handling of security, authentication, and request routing.

Modernization efforts should not only focus on adopting new technologies but also on leveraging proven design patterns to ensure scalability, resilience, and maintainability. Patterns like Strangler Fig, Saga, Circuit Breaker, Bulkhead, Event Sourcing, Repository, Sidecar, and CQRS provide essential strategies to ensure a scalable, resilient, and maintainable architecture. By integrating these patterns into modernization efforts, teams can avoid common pitfalls, minimize risks, improve system reliability, and create robust solutions for the future.

A version of this blog was first posted by Karsun expert Lakshman Maruri. Lakshman is an expert in our aviation portfolio. Connect with him on LinkedIn. Our Karsun Cloud Solutions experts use tools like those available in our Cloud Runways and Microservices Toolkits to accelerate transformation and build resilient, scalable architecture. Learn more at https://karsun-llc.com/innovation-center/modernization-and-transformation-toolkits/cloud-runways/

George Mason University students partnered with the Karsun Innovation Center to develop a rapid prototyping tool for microservices. Joseph Oliver, Artin Malekian and Habib Khalid worked directly with the innovation team on the rapid scaffolding tool. The seniors completed the work as part of their Industry-Sponsored Senior Design Project. Now in its second year, the senior capstone project integrates students’ computer science coursework with hands-on work with their capstone sponsor. The course is a unique opportunity to connect students of the Virginia-based university with the local IT industry. Including Karsun Solutions, eight companies sponsored the work of 28 students as part of the project.

The rapid scaffolding tool developed by the students aids in rapid prototyping for both monolith and microservices applications. Rapid prototyping is of utmost importance to enable human-centered design of software-intensive systems. As organizations build Lean teams, they seek opportunities to build minimum viable products (MVPs) faster with reduced initial cost. Quick set-up, using a rapid prototyping tool, gives teams this power. As an IT modernization firm specializing in modern software development, cloud solutions and advanced analytics, this project supports teams across Karsun

JHipster (https://www.jhipster.tech/) lets development teams generate application code for a variety of frameworks and languages. With this project, the intention was to extend JHipster to include support for additional languages and frameworks, so that the development teams get additional choices for building faster prototypes including polyglot microservices. In particular, the team focused their efforts on enhancing GoLang support for backend services.

The project was mentored by Badri Sriraman and Shanmuga Palanivelu. Badri is Vice President, Karsun Innovation Center (KIC) and the Chief Innovator at GoLean.io.  He is an accomplished Senior IT Architect, with over 22 years in developing solutions to modernize enterprise IT systems. Shanmuga has over 14 years of experience in software development doing software design, architecture and full-stack development. He is currently focused on both developing and deploying microservices at scale and implementing DevOps at scale.

Microservices innovation is one of several areas researched within our Karsun Innovation Center. This research and development unit consists of several prototyping teams and Centers of Excellence. These teams also act as subject matter experts, form vendor partnerships, arrange training and host a yearly internship. The innovation center is part of Karsun’s larger mentorship framework which includes industry associations, academic outreach and the Karsun Academy professional development program. We connect with both students and academics through hackathons, talks, and career fairs. The innovation center is still accepting Developer and DevOps interns into their summer program.