🚀 Migration Assessment Wizard - Interactive Tool¶

📋 Overview¶

The Migration Assessment Wizard is an interactive tool that guides you through assessing your current data infrastructure and planning a migration to Azure Synapse Analytics. This comprehensive demo helps you evaluate workloads, estimate effort, identify risks, and develop a migration roadmap.

🎯 Learning Objectives¶

By completing this interactive demo, you will be able to:

Assess current infrastructure and workloads for migration readiness
Identify compatible and incompatible features
Estimate migration effort and timeline
Calculate costs for target Azure environment
Identify migration risks and mitigation strategies
Generate a detailed migration plan with phases
Compare migration approaches (lift-and-shift vs. modernization)
Understand compliance and governance requirements

🎓 Prerequisites¶

Knowledge Requirements¶

Understanding of current data warehouse architecture
Familiarity with ETL/ELT processes
Basic knowledge of Azure services
Understanding of database migration concepts
Awareness of data governance requirements

Technical Requirements¶

Modern web browser (Chrome, Edge, Firefox, Safari)
JavaScript enabled
Ability to upload or input current system information
Access to current system metadata (optional but helpful)
Stable internet connection

Recommended Experience¶

Experience with data warehouse operations
Understanding of migration strategies
Familiarity with project planning
Basic knowledge of risk assessment
Understanding of compliance requirements

🚀 Demo Description¶

What This Demo Covers¶

The Migration Assessment Wizard provides:

Discovery Phase: Inventory current systems, workloads, and dependencies
Compatibility Analysis: Identify features that require changes
Effort Estimation: Calculate time and resources needed
Cost Analysis: Compare current vs. target costs
Risk Assessment: Identify potential blockers and challenges
Migration Strategy: Choose optimal migration approach
Roadmap Generation: Create phased migration plan

Demo Features¶

Multi-Step Wizard Interface¶

<!-- Migration Assessment Wizard -->
<div class="migration-wizard">
  <div class="wizard-progress">
    <div class="step active">1. Discovery</div>
    <div class="step">2. Analysis</div>
    <div class="step">3. Planning</div>
    <div class="step">4. Roadmap</div>
  </div>

  <div class="wizard-content">
    <div class="step-container" data-step="1">
      <!-- Discovery form content -->
    </div>
  </div>

  <div class="wizard-actions">
    <button class="btn-previous">Previous</button>
    <button class="btn-next">Next</button>
    <button class="btn-export">Export Report</button>
  </div>
</div>

Assessment Categories¶

// Migration assessment framework
const assessmentFramework = {
  technical: {
    categories: [
      'database_engines',
      'etl_tools',
      'bi_tools',
      'data_volume',
      'query_patterns',
      'security_features'
    ]
  },
  operational: {
    categories: [
      'maintenance_windows',
      'backup_strategies',
      'monitoring_tools',
      'alert_mechanisms',
      'team_skills'
    ]
  },
  business: {
    categories: [
      'sla_requirements',
      'compliance_needs',
      'budget_constraints',
      'timeline_expectations',
      'business_continuity'
    ]
  }
};

📝 Step-by-Step Guide¶

Phase 1: System Discovery (12 minutes)¶

Step 1: Enter Current Environment Details¶

Start the Migration Assessment Wizard
On the "Discovery" tab, select your current platform:
Source Platform: "On-premises SQL Server"
Version: "SQL Server 2016"
Edition: "Enterprise"
Enter infrastructure details:
Server Count: 3
Total Cores: 96
Total RAM: 768 GB
Total Storage: 50 TB

Expected Outcome: System captures baseline configuration

Step 2: Database Inventory¶

Click "Add Database" for each database to migrate:

Database 1: Sales_DW - Size: 15 TB - Tables: 450 - Views: 125 - Stored Procedures: 850 - Functions: 200 - Jobs: 35

Database 2: Marketing_Analytics - Size: 8 TB - Tables: 220 - Views: 75 - Stored Procedures: 420 - Functions: 95 - Jobs: 18

Upload database schema (optional):

-- Upload schema export or paste DDL
-- Wizard will parse and analyze automatically

Expected Outcome: Complete inventory of database objects

Step 3: Workload Characterization¶

Navigate to "Workload Profile" section
For each database, characterize workloads:

Sales_DW Workload: - Query Types: 60% reporting, 30% batch, 10% real-time - Concurrent Users: 150 - Peak Hours: 8 AM - 6 PM weekdays - Query Complexity: High - Update Frequency: Hourly - Critical Business Function: Yes

Add sample queries (optional):

-- Example query 1: Daily sales report
SELECT
    d.date,
    p.product_name,
    SUM(f.sales_amount) as total_sales
FROM fact_sales f
JOIN dim_date d ON f.date_key = d.date_key
JOIN dim_product p ON f.product_key = p.product_key
WHERE d.date >= DATEADD(day, -30, GETDATE())
GROUP BY d.date, p.product_name
ORDER BY d.date DESC;

Expected Outcome: System categorizes workload patterns

Step 4: Dependencies and Integration¶

Map external dependencies:
ETL Tools: SSIS, Informatica
BI Tools: Power BI, Tableau
Applications: 12 custom applications
Data Sources: 8 source systems
Data Consumers: 25 downstream systems

Document integration points:

{
  "integrations": [
    {
      "name": "Daily Sales Extract",
      "type": "SSIS Package",
      "frequency": "Daily",
      "criticality": "High",
      "dependencies": ["ERP System", "CRM System"]
    },
    {
      "name": "Real-time Dashboard",
      "type": "Power BI Direct Query",
      "frequency": "Real-time",
      "criticality": "Medium",
      "dependencies": ["Sales_DW"]
    }
  ]
}

Expected Outcome: Complete integration map created

Phase 2: Compatibility Analysis (10 minutes)¶

Step 5: Feature Compatibility Check¶

Click "Analyze Compatibility" button
Review compatibility report:

Compatibility Analysis Results:

Feature Compatibility Report
============================

✅ FULLY COMPATIBLE (No changes required)
- Basic SELECT/JOIN/WHERE queries: 2,450 queries
- Standard T-SQL functions: 850 occurrences
- Tables with standard data types: 580 tables
- Views without unsupported features: 180 views

⚠️ MINOR CHANGES REQUIRED (Easy to fix)
- Stored procedures with deprecated syntax: 85 procedures
- Queries using NOLOCK hints: 320 queries
- Triggers (need to convert to pipelines): 45 triggers
- Linked servers (need to use external tables): 12 links

❌ SIGNIFICANT CHANGES REQUIRED (Complex refactoring)
- CLR assemblies: 15 assemblies
- Extended stored procedures: 8 procedures
- Cursors in stored procedures: 120 occurrences
- Temp tables in views: 25 views
- Service Broker components: 5 queues

🚫 NOT COMPATIBLE (Alternative approach needed)
- Database mail: 1 mail profile
- Full-text search: 8 full-text catalogs
- SQL Server Agent jobs (convert to Azure Data Factory): 53 jobs
- Database mirroring: 1 mirror configuration

Step 6: Code Complexity Analysis¶

Review code analysis metrics:

Code Quality Metrics:

Code Complexity Analysis
========================

Total Lines of Code: 1,250,000
- T-SQL: 950,000 lines
- SSIS Packages: 200,000 (XML equivalent)
- Application Code: 100,000 lines

Complexity Distribution:
- Low Complexity: 65% (easy to migrate)
- Medium Complexity: 25% (moderate effort)
- High Complexity: 10% (significant refactoring)

Top Complexity Hotspots:
1. Sales_ETL_Proc_Master (2,500 lines, cyclomatic complexity: 45)
2. Customer_Data_Merge (1,800 lines, cyclomatic complexity: 38)
3. Product_Dimension_Load (1,200 lines, cyclomatic complexity: 32)

Recommendations:
- Refactor top 10 complex procedures before migration
- Consider breaking monolithic procedures into modules
- Implement error handling best practices

Step 7: Dependencies Impact Analysis¶

View dependency graph
Identify critical path dependencies:

Critical Dependencies
=====================

High-Impact Changes:
1. Sales_Fact table (350 dependent objects)
   - 45 stored procedures
   - 80 views
   - 12 Power BI reports
   - 5 SSIS packages

2. ETL Framework (120 dependent jobs)
   - Shared utility procedures
   - Logging framework
   - Error handling framework

Risk Assessment:
- Breaking changes: 15 objects
- High-risk refactoring: 35 objects
- Medium-risk updates: 180 objects
- Low-risk changes: 2,220 objects

Recommended Approach:
- Migrate framework components first
- Test extensively before dependent objects
- Consider parallel run period

Phase 3: Migration Planning (15 minutes)¶

Step 8: Effort Estimation¶

Click "Estimate Effort" button
Review effort breakdown:

Migration Effort Estimate:

Effort Estimation Report
=========================

Phase 1: Assessment & Planning
- Discovery and inventory: 40 hours
- Compatibility analysis: 60 hours
- Architecture design: 80 hours
- Migration planning: 60 hours
Subtotal: 240 hours (6 weeks)

Phase 2: Infrastructure Setup
- Azure environment provisioning: 40 hours
- Network configuration: 60 hours
- Security setup: 80 hours
- DevOps pipeline: 60 hours
Subtotal: 240 hours (6 weeks)

Phase 3: Schema Migration
- Schema conversion: 120 hours
- Object refactoring: 280 hours
- Testing: 160 hours
Subtotal: 560 hours (14 weeks)

Phase 4: Data Migration
- Data migration design: 60 hours
- Initial data load: 100 hours
- Validation: 80 hours
Subtotal: 240 hours (6 weeks)

Phase 5: Application Migration
- ETL pipeline conversion: 400 hours
- Application updates: 320 hours
- Integration testing: 240 hours
Subtotal: 960 hours (24 weeks)

Phase 6: Cutover & Optimization
- Cutover planning: 60 hours
- Production cutover: 80 hours
- Performance optimization: 120 hours
Subtotal: 260 hours (6.5 weeks)

TOTAL EFFORT: 2,500 hours (62.5 weeks)

Team Recommendation:
- Architects: 2 FTE
- Database Engineers: 4 FTE
- ETL Developers: 3 FTE
- Application Developers: 2 FTE
- QA Engineers: 2 FTE

Calendar Duration: 12-15 months

Step 9: Cost Comparison¶

Navigate to "Cost Analysis" tab
Review current vs. target costs:

Cost Comparison:

Total Cost of Ownership (TCO) Comparison
=========================================

Current On-Premises Environment (Annual):
-----------------------------------------
Hardware & Infrastructure:
- Servers (3-year amortization): $120,000
- Storage (50 TB SAN): $80,000
- Network equipment: $25,000
Subtotal: $225,000

Software Licenses:
- SQL Server Enterprise: $180,000
- ETL tools: $60,000
- Backup software: $20,000
Subtotal: $260,000

Operations:
- Data center: $50,000
- Power & cooling: $30,000
- Maintenance: $40,000
- IT staff (5 FTE): $500,000
Subtotal: $620,000

TOTAL CURRENT ANNUAL COST: $1,105,000

Target Azure Synapse Environment (Annual):
-------------------------------------------
Compute:
- Dedicated SQL Pools: $175,000
- Spark Pools: $85,000
Subtotal: $260,000

Storage:
- Data Lake Storage (50 TB): $30,000
- Backup storage: $8,000
Subtotal: $38,000

Services:
- Azure Data Factory: $45,000
- Azure Purview: $18,000
- Azure Monitor: $12,000
Subtotal: $75,000

Operations:
- Reduced IT staff (2 FTE): $200,000
- Training: $25,000
Subtotal: $225,000

TOTAL TARGET ANNUAL COST: $598,000

Migration Investment:
- One-time migration cost: $450,000

ROI Analysis:
- Annual savings: $507,000
- Payback period: 10.6 months
- 3-year savings: $1,521,000
- 5-year savings: $3,085,000

Step 10: Risk Assessment¶

Click "Assess Risks" button
Review identified risks and mitigation:

Risk Assessment Matrix:

Migration Risk Assessment
=========================

🔴 HIGH RISK
-----------
Risk: Data loss during migration
Impact: CRITICAL | Probability: LOW
Mitigation:
- Implement point-in-time restore strategy
- Use Azure Data Factory with validation
- Maintain parallel systems during cutover
- Plan rollback procedures

Risk: Extended downtime during cutover
Impact: HIGH | Probability: MEDIUM
Mitigation:
- Implement phased migration
- Use database mirroring/replication
- Schedule during maintenance windows
- Prepare rapid rollback plan

🟡 MEDIUM RISK
--------------
Risk: Performance degradation post-migration
Impact: MEDIUM | Probability: MEDIUM
Mitigation:
- Conduct performance testing in UAT
- Optimize queries for Azure Synapse
- Right-size resources
- Implement monitoring from day 1

Risk: Compatibility issues with applications
Impact: MEDIUM | Probability: MEDIUM
Mitigation:
- Comprehensive compatibility testing
- Update connection strings and drivers
- Implement application-side retries
- Maintain backward compatibility layer

🟢 LOW RISK
-----------
Risk: User adoption challenges
Impact: LOW | Probability: MEDIUM
Mitigation:
- Provide training programs
- Create documentation
- Assign change champions
- Offer ongoing support

Risk: Cost overruns
Impact: LOW | Probability: LOW
Mitigation:
- Implement cost monitoring
- Set budget alerts
- Use reserved capacity
- Regular cost optimization reviews

Phase 4: Migration Roadmap (8 minutes)¶

Step 11: Select Migration Strategy¶

Choose migration approach:

Option 1: Lift and Shift (Faster, less optimization) - Duration: 6-8 months - Effort: Lower - Cost savings: 35% - Performance improvement: Minimal - Modernization: Minimal

Option 2: Hybrid (Recommended) (Balanced) - Duration: 12-15 months - Effort: Moderate - Cost savings: 45% - Performance improvement: 30% - Modernization: Moderate

Option 3: Full Modernization (Longer, maximum benefits) - Duration: 18-24 months - Effort: Higher - Cost savings: 60% - Performance improvement: 50-70% - Modernization: Complete

Select "Option 2: Hybrid"

Step 12: Generate Migration Roadmap¶

Click "Generate Roadmap" button
Review phased migration plan:

Migration Roadmap:

Phase-by-Phase Migration Plan
==============================

🎯 Phase 1: Foundation (Months 1-3)
Objectives:
- Complete detailed assessment
- Design target architecture
- Set up Azure environment
- Establish governance

Key Deliverables:
- Architecture design document
- Migration strategy document
- Azure landing zone configured
- Security baseline implemented

Milestones:
✓ Assessment complete (Month 1)
✓ Architecture approved (Month 2)
✓ Azure environment ready (Month 3)

🎯 Phase 2: Pilot Migration (Months 4-6)
Objectives:
- Migrate non-critical workload (Marketing_Analytics)
- Validate migration approach
- Train team
- Refine processes

Key Deliverables:
- First database migrated
- Migration playbook created
- Team trained
- Lessons learned documented

Milestones:
✓ Schema migrated (Month 4)
✓ Data migrated (Month 5)
✓ Pilot in production (Month 6)

🎯 Phase 3: Core Migration (Months 7-10)
Objectives:
- Migrate critical workload (Sales_DW)
- Convert ETL pipelines
- Update applications
- Comprehensive testing

Key Deliverables:
- All databases migrated
- ETL pipelines in Azure Data Factory
- Applications updated
- Testing completed

Milestones:
✓ Sales_DW schema ready (Month 7)
✓ Data migration complete (Month 8)
✓ ETL pipelines converted (Month 9)
✓ Integration testing done (Month 10)

🎯 Phase 4: Cutover & Optimization (Months 11-12)
Objectives:
- Production cutover
- Decommission legacy system
- Performance optimization
- Knowledge transfer

Key Deliverables:
- Production cutover completed
- Legacy system decommissioned
- Performance baselines met
- Operations team trained

Milestones:
✓ Parallel run successful (Month 11)
✓ Cutover completed (Month 11)
✓ Optimization done (Month 12)
✓ Project closure (Month 12)

🎯 Phase 5: Continuous Improvement (Month 13+)
Objectives:
- Monitor and optimize
- Implement advanced features
- Cost optimization
- Modernization initiatives

Key Deliverables:
- Cost optimization achieved
- Advanced analytics enabled
- ML/AI capabilities added
- Full cloud-native operation

Step 13: Export Assessment Report¶

Click "Export Assessment Report" button
Choose export format:
PDF: Executive summary and detailed report
Excel: Data tables and calculations
PowerPoint: Presentation slides
JSON: Raw data for integration
Generated report includes:
Executive summary
Current state assessment
Compatibility analysis
Effort and cost estimates
Risk assessment
Migration roadmap
Recommendations

Sample Report Structure:

Migration Assessment Report
===========================

Executive Summary
-----------------
- Current Environment: SQL Server 2016 Enterprise (3 servers, 50 TB)
- Target Platform: Azure Synapse Analytics
- Migration Strategy: Hybrid (Lift & Optimize)
- Timeline: 12-15 months
- Estimated Effort: 2,500 hours
- Migration Cost: $450,000
- Annual Savings: $507,000
- ROI: 10.6 months

[Detailed sections follow...]

Appendices
----------
A. Database Inventory
B. Compatibility Matrix
C. Code Analysis Details
D. Cost Breakdown
E. Risk Register
F. Migration Checklist

🛠️ Technical Implementation Notes¶

Assessment Engine¶

# Migration assessment engine
from typing import Dict, List, Tuple
from dataclasses import dataclass
import re

@dataclass
class DatabaseObject:
    """Represents a database object to assess"""
    name: str
    type: str  # table, view, procedure, function
    size_mb: float
    complexity: int  # 1-10 scale
    dependencies: List[str]
    code: str = ""

class MigrationAssessor:
    """Core assessment engine"""

    def __init__(self):
        self.compatibility_rules = self._load_compatibility_rules()
        self.effort_model = self._load_effort_model()

    def assess_database(self, objects: List[DatabaseObject]) -> Dict:
        """Assess entire database for migration"""

        results = {
            'compatibility': self._assess_compatibility(objects),
            'effort': self._estimate_effort(objects),
            'risks': self._identify_risks(objects),
            'dependencies': self._analyze_dependencies(objects)
        }

        return results

    def _assess_compatibility(self, objects: List[DatabaseObject]) -> Dict:
        """Check compatibility of database objects"""

        compatibility_results = {
            'fully_compatible': [],
            'minor_changes': [],
            'major_changes': [],
            'not_compatible': []
        }

        for obj in objects:
            compatibility_level = self._check_object_compatibility(obj)
            compatibility_results[compatibility_level].append(obj)

        return compatibility_results

    def _check_object_compatibility(self, obj: DatabaseObject) -> str:
        """Check individual object compatibility"""

        incompatible_patterns = [
            r'OPENXML',
            r'::fn_\w+',  # CLR functions
            r'DBCC\s+',
            r'xp_\w+',  # Extended procedures
        ]

        major_change_patterns = [
            r'CURSOR',
            r'BEGIN\s+DISTRIBUTED\s+TRANSACTION',
            r'EXEC\s+sp_executesql',
            r'##\w+',  # Global temp tables
        ]

        minor_change_patterns = [
            r'WITH\s+\(NOLOCK\)',
            r'GETDATE\(\)',  # Prefer CURRENT_TIMESTAMP
            r'ISNULL\(',  # Prefer COALESCE
        ]

        # Check for incompatible patterns
        for pattern in incompatible_patterns:
            if re.search(pattern, obj.code, re.IGNORECASE):
                return 'not_compatible'

        # Check for major changes
        for pattern in major_change_patterns:
            if re.search(pattern, obj.code, re.IGNORECASE):
                return 'major_changes'

        # Check for minor changes
        for pattern in minor_change_patterns:
            if re.search(pattern, obj.code, re.IGNORECASE):
                return 'minor_changes'

        return 'fully_compatible'

    def _estimate_effort(self, objects: List[DatabaseObject]) -> Dict:
        """Estimate migration effort in hours"""

        effort_by_type = {
            'table': lambda obj: obj.size_mb / 1000 * 2,  # 2 hours per GB
            'view': lambda obj: obj.complexity * 1,
            'procedure': lambda obj: obj.complexity * 3,
            'function': lambda obj: obj.complexity * 2
        }

        total_effort = 0
        effort_breakdown = {}

        for obj in objects:
            if obj.type in effort_by_type:
                obj_effort = effort_by_type[obj.type](obj)
                total_effort += obj_effort
                effort_breakdown[obj.name] = obj_effort

        return {
            'total_hours': total_effort,
            'breakdown': effort_breakdown,
            'estimated_duration_weeks': total_effort / 40,  # Assuming 40 hours/week
        }

    def _identify_risks(self, objects: List[DatabaseObject]) -> List[Dict]:
        """Identify migration risks"""

        risks = []

        # Check for large tables (data migration risk)
        large_tables = [obj for obj in objects if obj.type == 'table' and obj.size_mb > 100000]
        if large_tables:
            risks.append({
                'category': 'data_migration',
                'severity': 'high',
                'description': f'{len(large_tables)} tables > 100 GB',
                'mitigation': 'Use parallel data migration, consider partitioning'
            })

        # Check for complex dependencies
        complex_objects = [obj for obj in objects if len(obj.dependencies) > 20]
        if complex_objects:
            risks.append({
                'category': 'dependencies',
                'severity': 'medium',
                'description': f'{len(complex_objects)} objects with >20 dependencies',
                'mitigation': 'Careful sequencing, thorough testing'
            })

        return risks

class CostEstimator:
    """Estimate migration and operational costs"""

    def __init__(self):
        self.azure_pricing = self._load_azure_pricing()

    def estimate_target_cost(self, current_env: Dict, target_config: Dict) -> Dict:
        """Estimate Azure Synapse costs"""

        # Compute costs
        sql_pool_cost = self._calculate_sql_pool_cost(target_config['sql_pool'])
        spark_pool_cost = self._calculate_spark_pool_cost(target_config['spark_pool'])

        # Storage costs
        storage_cost = target_config['storage_tb'] * 0.020 * 1024  # $0.020/GB/month

        # Service costs
        adf_cost = target_config['pipelines'] * 1.00  # $1/pipeline/month
        purview_cost = 500  # Base cost

        monthly_total = sql_pool_cost + spark_pool_cost + storage_cost + adf_cost + purview_cost

        return {
            'monthly': monthly_total,
            'annual': monthly_total * 12,
            'breakdown': {
                'compute': sql_pool_cost + spark_pool_cost,
                'storage': storage_cost,
                'services': adf_cost + purview_cost
            }
        }

    def calculate_roi(self, current_cost: float, target_cost: float,
                     migration_cost: float, years: int = 3) -> Dict:
        """Calculate ROI for migration"""

        annual_savings = current_cost - target_cost
        total_savings = annual_savings * years - migration_cost
        payback_period_months = migration_cost / (annual_savings / 12)

        return {
            'annual_savings': annual_savings,
            'total_savings': total_savings,
            'payback_period_months': payback_period_months,
            'roi_percent': (total_savings / migration_cost) * 100
        }

Roadmap Generator¶

class RoadmapGenerator:
    """Generate migration roadmap"""

    def generate_roadmap(self, assessment: Dict, strategy: str) -> Dict:
        """Generate phased migration roadmap"""

        phases = []

        # Phase 1: Assessment & Planning
        phases.append({
            'phase': 1,
            'name': 'Assessment & Planning',
            'duration_weeks': 12,
            'objectives': [
                'Complete detailed assessment',
                'Design target architecture',
                'Set up Azure environment',
                'Establish governance'
            ],
            'deliverables': [
                'Architecture design document',
                'Migration strategy document',
                'Azure landing zone',
                'Security baseline'
            ],
            'milestones': self._generate_phase1_milestones()
        })

        # Phase 2: Pilot Migration
        pilot_db = self._select_pilot_database(assessment)
        phases.append({
            'phase': 2,
            'name': 'Pilot Migration',
            'duration_weeks': 12,
            'target': pilot_db,
            'objectives': [
                f'Migrate {pilot_db} database',
                'Validate migration approach',
                'Train team',
                'Refine processes'
            ],
            'deliverables': [
                'First database migrated',
                'Migration playbook',
                'Team training completed',
                'Lessons learned'
            ],
            'milestones': self._generate_phase2_milestones(pilot_db)
        })

        # Additional phases...

        return {
            'strategy': strategy,
            'total_duration_months': sum(p['duration_weeks'] for p in phases) / 4,
            'phases': phases,
            'critical_path': self._identify_critical_path(phases),
            'resource_requirements': self._calculate_resource_requirements(phases)
        }

    def _select_pilot_database(self, assessment: Dict) -> str:
        """Select appropriate pilot database"""
        # Select smallest non-critical database with moderate complexity
        databases = assessment['databases']
        suitable = [db for db in databases if db['criticality'] == 'medium']
        return min(suitable, key=lambda db: db['size_tb'])['name']

Interactive UI¶

// React-based Migration Wizard
import React, { useState } from 'react';
import { useForm } from 'react-hook-form';

const MigrationWizard = () => {
  const [currentStep, setCurrentStep] = useState(1);
  const [assessment, setAssessment] = useState(null);
  const { register, handleSubmit } = useForm();

  const steps = [
    { id: 1, name: 'Discovery', component: DiscoveryStep },
    { id: 2, name: 'Analysis', component: AnalysisStep },
    { id: 3, name: 'Planning', component: PlanningStep },
    { id: 4, name: 'Roadmap', component: RoadmapStep }
  ];

  const onSubmitDiscovery = async (data) => {
    const response = await fetch('/api/migration/assess', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(data)
    });
    const result = await response.json();
    setAssessment(result);
    setCurrentStep(2);
  };

  const CurrentStepComponent = steps[currentStep - 1].component;

  return (
    <div className="migration-wizard">
      <WizardProgress steps={steps} currentStep={currentStep} />
      <CurrentStepComponent
        assessment={assessment}
        onComplete={(data) => handleStepComplete(data)}
      />
      <WizardNavigation
        currentStep={currentStep}
        totalSteps={steps.length}
        onPrevious={() => setCurrentStep(currentStep - 1)}
        onNext={() => setCurrentStep(currentStep + 1)}
      />
    </div>
  );
};

🎯 Key Takeaways¶

After completing this demo, you should understand:

Assessment Process: How to systematically evaluate migration readiness
Compatibility: Identify features that need changes or workarounds
Effort Estimation: Realistically estimate migration timeline and resources
Cost Analysis: Compare TCO and calculate ROI
Risk Management: Identify and mitigate migration risks
Migration Strategy: Choose appropriate migration approach
Roadmap Planning: Create phased migration plan

Documentation¶

Tools¶

External Resources¶

❓ FAQ¶

Q: Can this tool assess migrations from other platforms (Oracle, Teradata)? A: Yes, the wizard supports multiple source platforms including Oracle, Teradata, Netezza, and Redshift.

Q: How accurate are the effort estimates? A: Estimates are based on industry benchmarks and historical data. Actual effort may vary ±30% depending on specific circumstances.

Q: Can I save and resume the assessment? A: Yes, you can save your progress at any step and resume later. Use the "Save Progress" button.

Q: Does this generate actual migration scripts? A: The wizard generates high-level migration plans. Detailed scripts should be generated using Azure Database Migration Service or custom tools.

Q: How do I handle sensitive data during assessment? A: You can use anonymized metadata for assessment. Full data migration planning can be done without exposing sensitive data.

💬 Feedback¶

Help us improve the Migration Assessment Wizard!

Next Steps: - Review Migration Best Practices - Try Resource Planner for post-migration sizing - Explore Cost Calculator for detailed cost analysis

Last Updated: December 2025 | Version: 1.0.0