How to Transition From Legacy Systems

𝗠𝗼𝗱𝗲𝗿𝗻𝗶𝘇𝗶𝗻𝗴 𝗟𝗲𝗴𝗮𝗰𝘆 𝗔𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀 𝘄𝗶𝘁𝗵 𝗔𝗪𝗦: 𝗟𝗲𝘀𝘀𝗼𝗻𝘀 𝗟𝗲𝗮𝗿𝗻𝗲𝗱 Legacy applications can hold your business back: high maintenance costs, scalability challenges, and lack of agility. Modernizing with AWS offers a chance to unlock innovation, but it’s not without challenges. Here are some hard-earned lessons I’ve learned along the way: 1️⃣ 𝗕𝗿𝗲𝗮𝗸 𝗗𝗼𝘄𝗻 𝘁𝗵𝗲 𝗠𝗼𝗻𝗼𝗹𝗶𝘁𝗵 𝗦𝘁𝗲𝗽-𝗯𝘆-𝗦𝘁𝗲𝗽 Trying to refactor everything at once? That’s a recipe for disaster.  Instead, adopt an incremental approach: • Start by identifying business-critical components. • Migrate to microservices in stages using containers (ECS, EKS). • Introduce APIs gradually to reduce tight coupling. 2️⃣ 𝗖𝗵𝗼𝗼𝘀𝗲 𝘁𝗵𝗲 𝗥𝗶𝗴𝗵𝘁 𝗔𝗪𝗦 𝗦𝗲𝗿𝘃𝗶𝗰𝗲𝘀 AWS offers countless services, but not all are the right fit. Select based on your workload needs: • 𝗖𝗼𝗺𝗽𝘂𝘁𝗲: Lambda for event-driven tasks, ECS/EKS for containerized workloads. • 𝗦𝘁𝗼𝗿𝗮𝗴𝗲: S3 for static content, RDS or Aurora for relational workloads. • 𝗠𝗲𝘀𝘀𝗮𝗴𝗶𝗻𝗴: SQS and EventBridge for decoupling components. 3️⃣ 𝗔𝘂𝘁𝗼𝗺𝗮𝘁𝗲 𝗘𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴 Manual deployments and configurations increase complexity and risk. Use: • 𝗜𝗻𝗳𝗿𝗮𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 𝗮𝘀 𝗖𝗼𝗱𝗲 (𝗜𝗮𝗖): Terraform or AWS CloudFormation to define environments. • 𝗖𝗜/𝗖𝗗 𝗣𝗶𝗽𝗲𝗹𝗶𝗻𝗲𝘀: Automate testing and deployment with AWS CodePipeline. • 𝗠𝗼𝗻𝗶𝘁𝗼𝗿𝗶𝗻𝗴: CloudWatch and X-Ray to gain visibility and ensure performance. 4️⃣ 𝗕𝗮𝗹𝗮𝗻𝗰𝗲 𝗖𝗼𝘀𝘁 𝗮𝗻𝗱 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 Modernization doesn’t mean throwing money at the cloud. Optimize costs by: • Right-sizing EC2 instances or shifting to serverless where possible. • Using Savings Plans and auto-scaling to keep costs under control. • Leveraging AWS Cost Explorer to identify waste and optimize spending. 5️⃣ 𝗜𝗻𝘃𝗼𝗹𝘃𝗲 𝗦𝘁𝗮𝗸𝗲𝗵𝗼𝗹𝗱𝗲𝗿𝘀 𝗘𝗮𝗿𝗹𝘆 Modernization is not just a tech initiative; it’s a business transformation. Engage teams early to align goals and expectations across development, operations, and leadership. 6️⃣ 𝗙𝗼𝗰𝘂𝘀 𝗼𝗻 𝗤𝘂𝗶𝗰𝗸 𝗪𝗶𝗻𝘀 A successful modernization effort starts small, proves value, and expands. Identify low-risk, high-impact areas to deliver quick wins and build momentum. 💡 𝗣𝗿𝗼 𝗧𝗶𝗽: Modernization is an ongoing journey, not a one-time project. Continuously monitor, optimize, and adapt to stay ahead. What modernization challenges have you faced? #AWS #awscommunity

Exactly a year ago, we embarked on a transformative journey in application modernization, specifically harnessing generative AI to overhaul one of our client’s legacy systems. This initiative was challenging yet crucial for staying competitive: - Migrating outdated codebases - Mitigating high manual coding costs - Integrating legacy systems with cutting-edge platforms - Aligning technological upgrades with strategic business objectives Reflecting on this journey, here are the key lessons and outcomes we achieved through Gen AI in application modernization: [1] Assess Application Portfolio. We started by analyzing which applications were both outdated and critical, identifying those with the highest ROI for modernization.  This targeted approach helped prioritize efforts effectively. [2] Prioritize Practical Use Cases for Generative AI. For instance, automating code conversion from COBOL to Java reduced the overall manual coding time by 60%, significantly decreasing costs and increasing efficiency. [3] Pilot Gen AI Projects. We piloted a well-defined module, leading to a 30% reduction in time-to-market for new features, translating into faster responses to market demands and improved customer satisfaction. [4] Communicate Success and Scale Gradually. Post-pilot, we tracked key metrics such as code review time, deployment bugs, and overall time saved, demonstrating substantial business impacts to stakeholders and securing buy-in for wider implementation. [5] Embrace Change Management. We treated AI integration as a critical change in the operational model, aligning processes and stakeholder expectations with new technological capabilities. [6] Utilize Automation to Drive Innovation. Leveraging AI for routine coding tasks not only freed up developer time for strategic projects but also improved code quality by over 40%, reducing bugs and vulnerabilities significantly. [7] Opt for Managed Services When Appropriate. Managed services for routine maintenance allowed us to reallocate resources towards innovative projects, further driving our strategic objectives. Bonus Point: Establish a Center of Excellence (CoE). We have established CoE within our organization. It spearheaded AI implementations and established governance models, setting a benchmark for best practices that accelerated our learning curve and minimized pitfalls. You could modernize your legacy app by following similar steps! #modernization #appmodernization #legacysystem #genai #simform — PS. Visit my profile, Hiren Dhaduk, & subscribe to my weekly newsletter: - Get product engineering insights. - Catch up on the latest software trends. - Discover successful development strategies.

If you're prioritizing AI use cases, look for where your teams spend significant effort in order to understand massive amounts of data. With over 800 billion lines of legacy code running in production systems globally, using AI to understand that code is a perfect use case. Legacy code modernization has always been a major headache for businesses, and has been one of the toughest nuts to crack because... ☑️ Documentation is sparse or nonexistent (developers from the 1980s didn't exactly leave comments) ☑️ Institutional knowledge has walked out the door with many who know the language best retiring ☑️ The business logic is buried in millions of lines of interconnected, undocumented code The scale of this challenge is not small. 70% of Fortune 500 software was developed 20+ years ago, not to mention... ☑️ There's roughly 800+ billion lines of COBOL running in production systems globally ☑️ There are only ~24K active COBOL developers in the U.S. to support it ☑️ 95% of financial transactions still flow through COBOL code ☑️ 43% of global banking critical systems depend legacy code If your firm depends on legacy code for critical processes, modernizing is likely a strategic priority. And that effort isn't measured in months to completion, but decades. You've probably tried rule-based tools to automatically convert COBOL to Java, only to end up with "Jobol" that you understand no better than the original code. The code converts, but the comprehension doesn't. Imagine if you could train an AI model to understand COBOL. Could it tell you how these systems work in plain English? Where you can then decide for yourself the path forward? Morgan Stanley just did just this. Faced with this exact challenge, the team at Morgan Stanley built their own AI solution. In January, they rolled out DevGen.AI, an in-house tool built on OpenAI's GPT models that translates legacy code into plain English. The results speak for themselves: ✔️ 9M lines of code processed in just 5 months ✔️ 280,000 developer hours saved ✔️ 15,000 developers now have access to legacy system insights What did they learn? Don't try to automatically replace legacy code. Instead, use AI to translate what the code does into readable specifications that anyone can understand. If you aren't looking at AI for accelerating your system modernization, now is the time. Here's where I'd start... 1️⃣ Validate on a small, known system. Try evaluating specialized tools for this purpose. There are several startups out there for this purpose 2️⃣ Categorize your systems: what needs full modernization vs. AI support-only maintenance 3️⃣ Run strategic pilots on core modules (not a big bang approach) and deploy AI translation for teams supporting legacy systems (at least for now) The question isn't whether AI can handle this challenge, it's whether your organization will be among the first to unlock this competitive advantage. Morgan Stanley story: in comments #ai #legacymodernization

🚀 The Strangler Pattern: It’s the talk of the town in legacy system modernization—but how many are actually doing it? Spoiler alert: Not enough. Here’s the deal: The Strangler Pattern isn’t just a fancy term to throw around in meetings. It’s a practical, risk-managed approach to modernizing legacy systems that lets you build new features around the old, gradually replacing the legacy parts without pulling the rug out from under your users. But let’s get real. For all the hype, it’s rare to see it implemented effectively. Why? Because too many teams either don’t know where to start or they get bogged down in the complexities of their legacy systems. So, let’s cut through the noise with some actionable tips: 1️⃣ Start with Low-Hanging Fruit: Identify the parts of your system that are causing the most pain or are the easiest to replace. Begin by building new services around these components, gradually siphoning off functionality from the old system. Domain Driven Design tools like Event Storming are your friend! 2️⃣ Focus on Mission Value: Don’t just refactor for the sake of it. Target the areas that will deliver the most mission value. If your modernization efforts aren’t moving the needle, you’re wasting time. 3️⃣ Parallel Development: Run your legacy and new systems in parallel. This reduces risk by allowing you to validate the new system’s functionality before decommissioning the old one. It’s like having a safety net while you walk the tightrope. 4️⃣ Automate Testing and Deployment: Automation is your friend here. Use automated tests to ensure the new services work seamlessly with the old system. And automate your deployment pipeline to make the transition as smooth as possible. 5️⃣ Monitor and Iterate: Don’t just set it and forget it. Keep a close eye on the performance of both your old and new systems. Use feedback to continuously improve and gradually “strangle” the legacy system out of existence. 🏃♀️ Modernizing legacy systems is a marathon, not a sprint. The Strangler Pattern lets you pace yourself, but only if you commit to actually doing the work. It’s time to move beyond the buzzwords and start implementing. Who’s ready to stop talking about the Strangler Pattern and start using it? #LegacySystems #StranglerPattern #Modernization #TechDebt #SoftwareEngineering #DigitalTransformation #DevOps

If you work on a service that has non zero customers, chances are your projects are somewhat invovling migrating old to new, while keep the service running. The Strangler Migration pattern is a common model used to gradually migrate an existing service to a new system or technology stack. The key idea is to "strangle" the old system by incrementally replacing its functionality with the new system, similar to how a strangler fig plant grows around and eventually takes over an existing tree. This approach allows the migration to happen in a controlled and iterative manner, minimizing disruption to the existing application and its users. It involves creating a facade or proxy layer that routes requests to either the old or new system, gradually shifting more traffic to the new system over time. The Strangler Migration pattern is often used when the existing service is large, complex, or tightly coupled, service downtime is unacceptable or must be minimized, making a big-bang migration risky or impractical. It allows the new system to be developed and tested in parallel, while the old system continues to operate. Here are the key steps of the Strangler Migration process, specifically tailed for online services: 1. Prevention of New Dependencies * Stop new services from integrating with the legacy system * Ensure all new development connects to the new system * Establish clear guidelines for new development teams 2. Incremental Migration with Fallback * Gradually move existing dependencies from old to new system * Implement "kill switch" mechanism for safety * Allow quick rollback to old system if issues arise * Test each migration phase thoroughly * Monitor system behavior during transition 3. Complete Transition with Shadow Mode * Switch all use cases to the new system * Keep old system running in parallel (shadow mode) * Verify all functionality works correctly in new system * Compare outputs between old and new systems * Ensure no regression in business processes 4. Legacy System Decommissioning * Confirm all functionalities are working in new system * Verify no remaining dependencies on old system * Plan and execute resource cleanup * Document system retirement * Remove old system infrastructure If you are philosophy junkies like me, here is a bonus note: The Ship of Theseus paradox and the Strangler Fig Pattern are closely related concepts that deal with gradual replacement and identity. The Ship of Theseus is an ancient philosophical paradox about whether an object remains the same after all its components are gradually replaced. The paradox comes from a ship that had all its parts replaced over time, raising the question of whether it remained the same ship. Philosopher Thomas Hobbes asked - which ship would be the "original" if someone collected all the old parts and built another ship? Regardless what your answer is, migration is the only thing constant!

"Our systems are legacy. How do we adopt modern ABX?" I get this question a lot. Here's my take on modernizing legacy systems: Most enterprise marketing teams are stuck with legacy systems that weren't built for modern ABX. It's reality. It's ok. Good news is you can evolve without ripping everything out: Phase 1: Clean up your core data needs ↳ Audit the data flows between existing systems ↳ Document any manual processes and bottlenecks ↳ Create standardized data models for accounts ↳ Understand integrations between CRM and MAP Phase 2: Assess the gaps between current state and ideal state ↳ Identify which systems contain what customer data ↳ Understand current capabilities and limitations ↳ Deploy a standalone marketing CDP as your data hub ↳ Outline required ABX capabilities ↳ Document ideal customer data model Phase 3: Start to add some modern capabilities ↳ Layer in 2-3 off-the-shelf intent data platforms ↳ Start to personalize at the account-level ↳ Build out sample segments and buying groups ↳ Sequence 1-2 cross-channel orchestrations based on segments Phase 4: Begin to replace legacy systems as modern systems are operational ↳ Replace legacy components one at a time ↳ Migrate data sequentially based on revenue importance ↳ Validate new systems before retiring old ↳ Train your team on new tools and systems ↳ Report to stakeholders to maintain business continuity The key with legacy is technology evolution, not revolution. Modern ABX doesn't require throwing everything out. You can integrate new capabilities while maintaining more difficult to remove systems. Start with your data foundation. Clean, connected data will serve you better than shiny new tools on top of broken infrastructure.

Modern apps want APIs. Legacy IAM wants XML. Guess who wins? I’ve seen dev teams stall for weeks just trying to wire cloud-native apps into old identity systems. The backlog piles up, release cycles slip, and the cloud strategy starts to look like wishful thinking. Teams get stuck thinking they have to start from scratch. But you don’t need to rewrite everything—you just need identity that works the way your apps do now. Here’s the high-level playbook we’ve used with some of the largest enterprises: 1. Inventory what you have: Map your apps, IDPs, and the tech each one uses. Knowing your current state is half the battle. 2. Classify and prioritize: Start with the apps that are most critical and easiest to modernize — especially those that already support standards like SAML or OIDC. 3. Assess your IDPs: Understand which are cloud-based vs. on-prem, and which are ready to retire. 4. Connect with an identity fabric: Use an abstraction layer to unify identity across your apps and IDPs — this gives you one control point to manage from. 5. Orchestrate the transition: Migrate apps in phases, moving sessions from legacy IDPs to modern ones without rewriting code. 6. Enable modern auth everywhere: Bring capabilities like passwordless to your legacy apps — without touching the apps themselves. It doesn’t need to be all-or-nothing. With orchestration, identity modernization becomes a continuous, incremental path forward — not a risky big-bang cutover. Want to go deeper? I share more on how to modernize app identity at scale in this post: Modernizing Application Identity at Scale: https://lnkd.in/gBb7j9xt

Database Drama and Migration Magic: Tales from the Customer Advisory Board At our largest-ever CABs, we heard from leaders across multiple industries— and one theme stood out: database modernization is now a critical priority. Why Modernize? 1. Escape Legacy Constraints: Legacy relational databases are limiting. Slow releases, performance bottlenecks, and an inability to manage new data types are forcing businesses to look for more agile, scalable, and flexible solutions. MongoDB is designed to handle diverse, complex data at the speed users now expect from their apps. 2. Support GenAI Workloads: GenAI requires real-time access to vast, varied datasets, pushing traditional systems to their limits. MongoDB is optimized for high-throughput, low-latency workloads, unlocking AI’s potential. 3. Enable Hybrid and Multi-Cloud: As businesses adopt hybrid and multi-cloud environments—often as part of moving from monolithic apps to microservices—a modern database that runs consistently across clouds and on-prem is essential, simplifying your tech stack. What’s Holding Companies Back? App Prioritization: Many teams struggle to get started, finding it hard to prioritize which legacy apps to modernize. Determining each app’s strategic value and aligning it with business objectives is often unclear, delaying progress. Upskilling Teams: Modernizing databases requires teams to learn new skills, like using document databases or migrating to hyperscalers. Shifting from relational systems to modern architectures demands updates in database administration and development.. Consistent, Scalable Migrations: Even with priorities and skilled teams, migration can be overwhelming. Without the right tools, it risks being slow, inconsistent, costly, and error-prone. Automated, repeatable solutions are key to efficient, scalable migrations across apps and teams. How We Can Help At MongoDB, we make database modernization easier: Start Small with a Proof of Concept: - Use our Relational Migrator to automate the initial migration steps and validate your approach. Strategic Migration Planning: - Our purpose built Relational Migration Methodology helps you prioritize apps, build a solid business case, and align modernization with your goals. Scale Automation with Relational Migrator: - Once you’re ready to scale, our tools automate schema design, code conversion, and even allow you to integrate your own LLMs—all while ensuring security and consistency. Get Migration Assistance: - You’re not alone in your migration journey. Our Professional Services team offers deep MongoDB expertise in planning, application development, and training, while our Migration Partners support broader digital transformation efforts. Real-World Impact Bendigo and Adelaide Bank used MongoDB’s tools to streamline their migration. See my previous post here: https://lnkd.in/g4VQqFhh Ready to modernize? Drop a comment to explore how we can help you!

How to tackle legacy system modernization at scale: How Booking(.)com tackled a legacy API that had gotten completely out of hand: The situation: A 14-year-old API in their Perl monolith had grown from handling simple app updates to managing 21 different features across 7 teams. Instead of a quick migration to Java, the team took a thoughtful approach to breaking down this complex system. Key insights from their successful modernization: 1. Map before you migrate. The team created visual diagrams to understand how 1,500 lines of code connected to various parts of their system. 2. Know your stakeholders. Using repository history, they identified every team dependent on the API and included them in the planning process. 3. Split strategically. They separated the system into focused services based on functionality and platform requirements, making it more maintainable. 4. Test thoroughly. When they encountered unexpected issues with marketing metrics, they used A/B testing to identify and fix problems without disrupting service. The biggest lesson? Modernizing legacy systems isn't just rushing to new technology. It's about understanding what you have and carefully restructuring it into something better. Follow Pratik Daga for daily informative posts on software engineering.