> Markdown version of [/videos/120-application-modernization-and-rabbits?t=180](https://www.wearedevelopers.com/videos/120-application-modernization-and-rabbits?t=180). Every page supports `.md` or `Accept: text/markdown`. Links point to the HTML versions so they work for humans too. Agent guide: [/agents.md](https://www.wearedevelopers.com/agents.md). --- # Application Modernization and Rabbits Managing a legacy monolith is like keeping a growing rabbit population in a crowded cage. Discover how to iteratively untangle systems into event-driven microservices without boiling the ocean. - **Speakers:** Niklas Heidloff - **Event:** WeAreDevelopers LIVE - **Published:** March 23, 2021 - **Duration:** 33:40 - **URL:** https://www.wearedevelopers.com/videos/120-application-modernization-and-rabbits ## Summary Application modernization is best understood as a transition from a single monolithic structure to a network of resilient, interconnected components. Using an analogy of managing a growing rabbit population, moving from a crowded cage to connected hutches mirrors the shift from legacy monoliths to microservices, enabling targeted upgrades without system-wide downtime. Successful modernization avoids "boiling the ocean" by treating the shift as an iterative journey. Organizations should take baby steps—such as migrating initial application tiers into containers—to achieve immediate operational consistency and evaluate value before committing to deep code refactoring.<br><br>The modernization process often begins with standardizing runtimes. Tools like the IBM cloud transformation advisor can analyze legacy applications to generate necessary configuration files, paving the way for open-source frameworks with Jakarta EE compatibility. True agility is unlocked when decoupling the monolith using the strangler fig pattern. By leveraging AI-assisted boundary analysis tools to model runtime interactions, developers can extract high-traffic bounded contexts into independent microservices. To prevent the anti-pattern of creating a "distributed monolith," the architecture must eliminate synchronous blocking dependencies, relying instead on event-driven decoupling with Apache Kafka and reactive frameworks like quarkus to boost asynchronous performance and reduce JVM memory consumption.<br><br>Backend improvements must be matched by frontend modularity to fully realize agile delivery. Adopting a micro frontend architecture utilizing federated UI components and reactive inter-component messaging resolves the bottleneck of a single monolithic interface. By combining modern practices like the backend-for-frontend pattern with an isolated frontend ecosystem, development teams can independently scale, update, and release specific features across the entire stack without disrupting the overall end-user experience. **Keywords:** application modernization, microservices architecture, legacy monolith migration, strangler fig pattern, distributed monolith anti-pattern, backend-for-frontend pattern, containerization strategy, event-driven decoupling, micro frontend federation, reactive java frameworks, quarkus runtime efficiency, open liberty migration, jakarta EE compatibility, IBM cloud transformation advisor, AI-assisted dependency analysis, single-spa UI framework, apache kafka integration ## Chapters 1. **Application modernization explained through rabbit habitats** (00:00) — Expanding rabbit cages into connected hutches illustrates the agility and efficiency of migrating from monoliths to microservices architectures. 1. **Five core strategies for handling legacy applications** (03:00) — Retiring, migrating, or refactoring older monolithic applications balances cost with the need for competitive software delivery. 1. **Comparing a legacy e-commerce application with modernized architecture** (05:21) — Side-by-side demonstrations of a monolithic Dojo toolkit application and a fully containerized microservices structure clarify the transition path. 1. **Taking incremental steps in an application modernization journey** (07:15) — Breaking a massive architectural overhaul into smaller verifiable phases limits operational risk and proves immediate value. 1. **Migrating monolithic workloads from virtual machines to containers** (09:29) — Tools like cloud transformation advisor automate the generation of container configurations and identify necessary code updates for modern runtimes. 1. **Decoupling interfaces and upgrading to open source application runtimes** (12:50) — Separating interface logic using the backend for frontend pattern and adopting community-supported software reduces licensing costs and simplifies scaling. 1. **Adopting the strangler pattern for initial microservices extraction** (15:33) — Incrementally peeling off high-traffic user flows from legacy systems preserves core application stability while scaling specific functions. 1. **Using runtime analysis tools to identify optimal microservice boundaries** (18:17) — Analyzing method invocation chains helps isolate standalone technical domains and prevents the creation of brittle distributed monoliths. 1. **Implementing event-driven architectures to decouple remote service components** (21:29) — Replacing synchronous rest calls with asynchronous messaging and database caching ensures separate architectural domains can function independently. 1. **Selecting efficient java virtual machines and reactive application frameworks** (24:02) — Adopting memory-optimized engines and reactive endpoints drastically reduces container resource consumption and improves high-volume request handling. 1. **Decomposing monolithic user interfaces into responsive micro front ends** (27:08) — Federated interface architectures allow individual technical teams to deploy specific graphical components without blocking broader application releases. 1. **Cloning and deploying the modernized application architecture locally** (31:44) — Accessing sample scripts and open source repositories jumpstarts practical exploration of containerized deployment models. ## Related Moments - [Modernizing legacy applications through proactive leadership](https://www.wearedevelopers.com/videos/1223-coffee-with-developers-babette-wagner) (from "Coffee with Developers - Babette Wagner") - [Transforming legacy monoliths into modern software systems](https://www.wearedevelopers.com/videos/845-domain-driven-transformation-how-to-bring-back-sustainable-architecture-to-legacy-and-monoliths) (from "Domain-Driven Transformation—How to Bring (Back) Sustainable Architecture to Legacy and Monoliths") - [Incremental frontend modernization avoiding full rewrites](https://www.wearedevelopers.com/videos/873-interface-contracts-in-microfrontend-architectures) (from "Interface Contracts in Microfrontend Architectures") - [Modernizing a legacy Java ERP monolithic architecture](https://www.wearedevelopers.com/videos/100009-goodbye-microservices-hello-self-contained-systems) (from "Goodbye Microservices, Hello Self-Contained Systems") - [Overcoming modernization challenges in aging monolithic codebases](https://www.wearedevelopers.com/videos/1587-web-fragments-incremental-micro-frontends-migration-approach-for-enterprise) (from "Web-Fragments: incremental micro-frontends migration approach for enterprise") - [Transforming to a cloud-native modular application architecture](https://www.wearedevelopers.com/videos/1444-crew-management-system-for-airlines-plan-duties-for-pilots-flight-attendants-worldwide) (from "Crew Management System for Airlines: Plan duties for pilots & flight attendants worldwide") ## Related Articles - [Now is the time for industrialized software development](https://www.wearedevelopers.com/magazine/601-now-is-the-time-for-industrialized-software-development) - [How to Avoid Over-Engineering](https://www.wearedevelopers.com/magazine/546-how-to-avoid-over-engineering) - [Why You Shouldn’t Build a Microservice Architecture](https://www.wearedevelopers.com/magazine/118-why-you-shouldn-t-build-a-microservice-architecture) - [Building AI Solutions with Rust and Docker](https://www.wearedevelopers.com/magazine/494-building-ai-solutions-with-rust-and-docker) ## Related Jobs - [Platform Engineer - Mercury Runtime Platform](https://www.wearedevelopers.com/jobs/ext/293235-platform-engineer-mercury-runtime-platform) at **Raiffeisen Bank International AG** - [Senior Backend Engineer (Java)](https://www.wearedevelopers.com/jobs/ext/19369-senior-backend-engineer-java) at **Bonial International GmbH** - [Mid/Senior Full-Stack Engineer (Web-first)](https://www.wearedevelopers.com/jobs/ext/1210833-mid-senior-full-stack-engineer-web-first) at **SMG Swiss Marketplace Group** - [Platform Engineer (f/m/x) - Mercury Runtime Platform](https://www.wearedevelopers.com/jobs/48266-platform-engineer-f-m-x-mercury-runtime-platform) at **Raiffeisen Bank International AG** - [Staff Frontend Engineer](https://www.wearedevelopers.com/jobs/48313-staff-frontend-engineer) at **SMG Swiss Marketplace Group** - [Staff Frontend Engineer (Expert+/Lead equivalent) - Hybrid working model, 100%, Ho Chi Minh City](https://www.wearedevelopers.com/jobs/48314-staff-frontend-engineer-expert-lead-equivalent-hybrid-working-model-100-ho-chi-minh-city) at **SMG Swiss Marketplace Group**