Modernizing complex applications requires more than tools and effort. It requires a clear application modernization strategy that aligns teams, defines priorities, and connects architectural understanding to execution.
For teams working with complex systems, this is not a side project. Modernization must be carried out thoughtfully and efficiently, with a shared understanding of how changes affect critical applications. Modernizing complex applications involves moving from understanding how systems behave to modularizing, transforming, and managing them as standalone services. This lifecycle provides the foundation for a modern application modernization strategy, connecting each phase from understanding to transformation and ongoing management.
vFunction supports a continuous application modernization lifecycle to understand, transform, and manage complex applications.
With vFunction 4.6, this progression becomes more agentic by linking architectural understanding directly to guided actions throughout the modernization lifecycle, enabling teams to move from insight to execution in a more continuous, coordinated way.
In our latest release, we’re introducing:
- Agentic transformation to move from plan to execution
- An automated modernization plan that teams can share
- vFunction Agent support for distributed applications
A modernization plan you can generate and share
Modernizing mission-critical applications requires architects, developers, and leadership to have a clear understanding of what’s changing, why it matters, and phased plans that align with business priorities. Too often, modernization tasks remain buried in tools or within individual teams, making it difficult to build alignment and sustain progress.
With vFunction 4.6, teams can move from defining an application modernization strategy to executing it through a clear, structured plan. The platform automatically generates a plan based on the application’s architecture. Delivered in Markdown, it fits naturally into engineering workflows, can be versioned in Git, and shared across the organization. It can also be exported as a PDF, making it accessible to both technical and non-technical stakeholders.
The vFunction plan includes a detailed view of the application’s current state: technology stack, domains, and architectural complexity, along with prioritized TODOs. From there, it lays out a clear phase-by-phase execution path, helping teams understand what to address first, what comes next, and how to modernize incrementally.
vFunction-generated modernization plan, delivered as Markdown and viewable in VSCode
GenAI-styled modernization plan generated from vFunction’s Markdown, enabling teams
to edit and refine based on their needs
vFunction Agent support for distributed applications
Many of the systems we work with today are distributed architectures, often without clear boundaries or consistent design. Understanding real service interactions is critical to identifying where systems are tightly coupled and where to intervene. In many cases, these applications are effectively distributed monoliths, where services are separated but remain tightly coupled, making it difficult to understand behavior, trace dependencies, and accelerate engineering velocity.
With vFunction 4.6, the vFunction Agent now supports distributed applications, enabling teams to explore these complex systems via chat and queries. Teams can ask questions such as:
- Show all flows where the database table X is accessed
- Identify flows with repeated calls to service A
- Show interactions where service A calls service B
Architectural prompts for distributed applications
By analyzing real service interactions, vFunction shows how systems actually behave and generates prompts that guide coordinated, system-level improvements, such as:
- Replacing inefficient loops with bulk APIs to reduce excessive service calls
- Consolidating repeated calls into compound APIs that eliminate redundant interactions
vFunction exposes inefficient patterns, dependencies, and cross-service coupling that static analysis or APMs often miss. Its architectural analysis enables coordinated, system-aware modernization that keeps distributed systems aligned as they evolve. Moreover, vFunction provides automatic prompts for code assistants like Kiro or Cursor to fix antipatterns in the codebase.
Agentic transformation
A strong application modernization strategy doesn’t stop at defining domains or isolating services. It must extend into transformation.
Once services are identified, they still need to be transformed: upgrading frameworks, refactoring code, and aligning them with modern architectures across technologies such as Java and .NET. Without architectural context and coordination, this step becomes time-consuming and difficult to standardize across teams.
With vFunction 4.6, once services are isolated, vFunction generates prompts that guide code assistants in transforming and upgrading them, enabling framework and technology conversions such as:
- JEE to Spring Boot
- Struts to REST
By combining service-level context with prompt-driven execution, vFunction enables teams to refactor and modernize services in a consistent, architecture-aligned way, turning modernization into a guided, repeatable process.
Delivering on AI-driven, end-to-end modernization
A successful application modernization strategy connects architectural insight to execution across the modernization lifecycle in a consistent, coordinated, and repeatable way.
With vFunction 4.6, this modernization becomes more continuous and actionable, driven by real data and aligned across teams and workflows.
