Monolithic Application Modernization

Overview

This document outlines the typical stages and activities involved when an application team decides to modernize a monolithic application using vFunction. The document is meant as a general reference, although details may vary between different applications and organizations.

The vFunction modernization process follows a structured, iterative approach:

  1. Install required agents and environment components
  2. Learn the application’s runtime behavior
  3. Analyze domains for logical and technical boundaries
  4. Refactor identified components with automation support
  5. Extract stable domains into independent services
  6. Upgrade frameworks and add modern capabilities

Installation

vFunction requires three elements to be installed in the client environment:

  • Install vFunction Server
  • Install vFunction Dynamic Agent (Java or .NET)
  • Install vFunction Static Agent

Each of these elements has its own prerequisites, and may require different credentials in order to install them. The tables below details the resources required, people and net-time that should be planned for the task.

Resources Required
Resource
Description
Server Host A machine (bare metal or virtual) or container cluster (any Docker or Kubernetes flavor) for installing the vFunction Server. Prerequisites
Dynamic Agent Host A running monolithic application environment where the vFunction Dynamic Agent is installed. Start with pre-production. Some teams later install it in production for more accurate logic coverage and dead code analysis. Prerequisites
Static Agent Host (Viper) A machine or container with access to the application binaries on the file system for vFunction Static Agent installation. Prerequisites
People Required
Role
Responsibility
DevOps Engineer Install vFunction components on the specified resources.
Developer or DevOps Engineer Configure the application to run with the vFunction Dynamic Agent.
Typical Time Required
Task
Typical net time
(assumes that prerequisites are met)
Server Installation 2-3 hours
Agents Installation 1-2 hours

Learning

The learning, analysis and refactoring stages of working with vFunction are part of an iterative process. In each iteration the application is learned by vFunction, the target architecture is refined and refactoring steps are recalculated. Typically, a single iteration will show significant value towards modernizing the application. The number of iterations is based on the prioritization of refactoring tasks and the deployment process of the updated application.

The Learning stage allows vFunction to learn the behavior of the monolithic application. The list and tables below show guidelines for learning as well as the people and time commitments for learning.

Guidelines
  • The application version must match and remain unchanged between the static and dynamic agents during a Learning cycle
  • In Pre-Production, run the regression test suite covering diverse logical flows. Load testing is not required.
  • The duration depends on how long the regression suite takes.
  • In Production, 1-2 days of typical usage usually provides adequate workflow coverage.
  • Periodic tasks such as monthly reports can be captured when they run or replicated through pre-production tests.
  • Learning can combine traffic from both environments.
People Required
Role
Responsibility
QA Engineers Execute automated or manual regression tests
Typical Time Required
Task
Typical net time
(assumes that prerequisites are met)
Production Testing 0 hours (passive learning)
Automated Testing 0 hours (passive learning)
Manual Testing 10-40 hours (running sanity tests and regression on major features)

Analysis

The learning, analysis and refactoring stages of working with vFunction are part of an iterative process. In each iteration the application is learned by vFunction, the target architecture is refined and refactoring steps are recalculated. Typically, a single iteration will show significant value towards modernizing the application. The number of iterations is based on the prioritization of refactoring tasks and the deployment process of the updated application.

In the Analysis phase, the team reviews vFunction’s Learning output and aligns it with the business objectives. The list and tables below show the activities that take place during the Analysis phase, some common refactoring items as well as the people and time commitments for analysis.

Activities
  • Identify functional/business logic domains based on the measurement acquired by learning
  • Translate vFunction’s technical domains into business logic domains
  • Establish a draft baseline of all domains, then select one domain with business value for detailed refinement.
  • Prioritize the vFunction TODO items (auto and user defined) for the iteration using the baseline measurement. Optionally create work items in your development ticketing system (e.g., Jira)
Common Refactoring Items
  • Split facade layer classes into focused, domain-specific ones
  • Refactor service layer methods to remove unnecessary cross-domain dependencies
  • Improve data encapsulation by cleaning up unexpected table access. This allows future database decomposition
  • Simplify “God” objects with excessive dependencies to reduce the domain’s class footprint
People Required
Role
Responsibility
Application Architect /
Senior Engineer		 Lead analysis and technical mapping
Business Analyst /
Senior QA /
Domain SME		 Provide business and functional context
Typical Time Required
Task
Typical net time
(assumes that prerequisites are met)
Analyse with vFunction 1-4 days
Review refactoring tasks 2-4 hours

Refactoring

The learning, analysis and refactoring stages of working with vFunction are part of an iterative process. In each iteration the application is learned by vFunction, the target architecture is refined and refactoring steps are recalculated. Typically, a single iteration will show significant value towards modernizing the application. The number of iterations is based on the prioritization of refactoring tasks and the deployment process of the updated application.

The Refactoring phase addresses the refactoring tasks identified during Analysis. After the refactoring is complete, start another iteration by doing learning again and getting an up-to-date status of the TODO items over the baseline. The lists and tables below describe the process of refactoring as well as the resources, people and time commitments during the refactoring phase.

Process
  • vFunction generates prompts consumed by AI Coding Assistants (e.g. Amazon Q Developer, GitHub Copilot, Claude Code, etc.).
  • The AI automates most refactoring; developers verify and complete missing tasks (such as unit tests).
  • The process repeats through Learning → Analysis → Refactoring until the domain becomes independent.
Resources Required
Tool
Purpose
AI Coding Assistant Automate and assist with refactoring
People Required
Role
Responsibility
Application Developer Perform code refactoring
QA Engineer Validate correctness and stability
Typical Time Required
Task
Typical net time
(assumes that prerequisites are met)
Implement refactoring items
  • 1-2 hours per refactoring item with AI Coding Assistant
  • 1–8 hours per refactoring item without AI Coding Assistant
  • Note: Application size, complexity and developer expertise may impact refactoring time
Validate refactoring items 1-8 hours depending on manual or automated QA validation of refactoring items

Service Extraction

Once a decision is made to extract a domain as an independent service separate from the rest of the monolith, it is extracted into a standalone service. The list and tables below describe the activities as well as people and time commitments.

Activities
  • Extract the domain from the monolithic codebase into a new project
  • vFunction adds framework wrappers where needed (e.g., Spring Web Controllers exposing REST APIs)
People Required
Role
Responsibility
Application Developer Compile, build, and deploy the extracted service
DevOps Engineer (optional) Support deployment and configuration
Typical Time Required
Task
Typical net time
(assumes that prerequisites are met)
Extract <1 hour
Compile 1-2 hours
Deploy 1-4 hours

Technical Stack Upgrades

As part of the extraction process, an organization can upgrade the extracted service’s frameworks and integrate modern components. For example:

  • Spring → Spring Boot
  • J2EE → Quarkus
  • .NET Framework 4 → .NET 8
  • Containerization
  • Add enhanced security, service mesh integration, circuit breakers, distributed caching, etc

The tables below describe the resources, people and time commitments for the Technical Stack Upgrades phase.

Resources Required
Tool
Purpose
AI Coding Assistant Assist with code modernization and upgrades
People Required
Role
Responsibility
Application Developer Perform framework and infrastructure upgrades
QA Engineer alidate service integrity and functionality
Typical Time Required
Task
Typical net time
(assumes that prerequisites are met)
Upgrade frameworks
  • 4-8 hours with AI Coding Assistant
  • 4-40 hours without AI Coding Assistant
  • Note: These numbers depend on the number of framework transformations and how old the source frameworks are. E.g. A Spring 5 to Springboot 3 transformation can be relatively straightforward. A Java EE 5 to Springboot 3 transformation can be quite involved
Validate upgrades 2-16 hours depending on level of test development required

Updated on 13 Nov 2025