Skip to main content
Modernization goals are your starting point. They tell what you want to accomplish, and everything else—instructions, architecture, milestones—flows from this input.

​
Why This Matters

Your modernization goals become the foundation for the entire migration. uses them to:
  • Analyze which parts of your source code are relevant
  • Determine the target technology stack
  • Generate detailed migration instructions
  • Plan the milestone sequence
Vague goals produce vague results. Specific goals produce a focused, actionable plan.

​
Writing Effective Goals

​
Be Specific About Technologies

Instead of general statements, name the specific technologies:
Less EffectiveMore Effective
”Modernize the backend""Migrate from Express.js to FastAPI"
"Update Python""Upgrade from Python 2.7 to Python 3.12"
"Use a modern frontend""Migrate from AngularJS to React 18 with TypeScript”

​
State the Transformation

Describe both where you’re coming from and where you’re going:
  • “Translate the source code from Ada to C++”
  • “Upgrade Java 8 with Spring Boot 2 to Java 21 with Spring Boot 3”
  • “Migrate from jQuery to vanilla JavaScript ES2022”

​
Include Version Numbers When Relevant

Version specificity helps make the right choices:
  • “Upgrade to Python 3.12” (not just “Python 3”)
  • “Use React 18 with hooks” (not just “React”)
  • “Target Java 21 LTS” (not just “latest Java”)

​
Using Advanced Options

Click Advanced Options to access additional fields.

​
Additional Instructions

Use this for requirements that don’t fit in the main goal: Examples:
  • “Use pytest for all tests with 80% coverage target”
  • “Apply the repository pattern for database access”
  • “Use our company’s standard logging format”
  • “Prefer functional components over class components”
  • “Keep the existing API contracts unchanged”
This is where you encode specific technical decisions or constraints.

​
Modernization Scope

By default, migrates your entire repository. Use this field to focus on specific parts: Examples:
  • src/backend/ — Only migrate the backend folder
  • packages/core/ — Focus on a specific package
  • src/legacy-module/ — Target a legacy module
Leave empty to migrate everything.

​
Example Goals

​
Language Translation

Translate the source code from Ada to C++
Additional Instructions: 
- Use modern C++20 features where appropriate
- Maintain the same module structure
- Generate CMake build configuration

​
Framework Migration

Migrate from AngularJS to React with TypeScript
Additional Instructions: 
- Use functional components with hooks
- Implement state management with React Context
- Use CSS Modules for styling
- Maintain the same routing structure

​
Language Upgrade

Upgrade Python 2.7 to Python 3.12
Additional Instructions: 
- Use type hints throughout
- Replace deprecated libraries with modern equivalents
- Use pathlib instead of os.path
- Maintain backward compatibility for the public API

​
Architecture Change

Refactor the monolithic application to use a service-oriented architecture
Additional Instructions: 
- Create separate services for user management, orders, and inventory
- Use REST APIs for inter-service communication
- Implement shared types in a common package
- Generate Docker configurations for each service

​
What Happens Next

After you submit your goals, :
  1. Generates Source Architecture — Documents your current codebase structure
  2. Generates Modernization Instructions — Creates detailed project specifications for your migration
You’ll review and approve these instructions before any migration begins. See Modernization Instructions for details.