Upgrading from Business Central version 14 represents one of the most significant modernization challenges in the Microsoft Dynamics ecosystem. Version 14 was the last release supporting on-premises deployment with the traditional C/AL development model, making this upgrade a fundamental architectural transformation rather than a simple version update.

The technical complexity stems from multiple simultaneous transitions: C/AL to AL code conversion, client-server to web-based architecture, object modification to extension-based development, and traditional deployment to cloud-native operations. Each aspect requires specialized knowledge and careful planning to ensure successful implementation.

Technical Architecture Evolution

Platform Foundation Changes

Version 14 Architecture:

• Windows client with limited web client functionality
• Direct database connectivity through proprietary protocols
• C/AL programming language with object-based development
• Monolithic deployment requiring client installation management
• Limited API capabilities and integration flexibility

Modern Business Central Architecture:

• Web-first design with responsive browser and mobile applications
• Service-oriented architecture with comprehensive API framework
• AL programming language with extension-based customization model
• Cloud-native deployment with automatic updates and scaling
• Rich integration ecosystem supporting modern business requirements

Development Model Transformation

The shift from C/AL to AL represents more than syntax changes—it fundamentally alters how customizations integrate with the base application:

// Legacy C/AL modification pattern (v14)
OBJECT Table 18 Customer
{
  OBJECT-PROPERTIES
  {
    Modified=Yes;
  }
  PROPERTIES
  {
    OnInsert=VAR
               Setup@1000 : Record 311;
             BEGIN
               // Custom logic here
               IF "No." = '' THEN BEGIN
                 Setup.GET;
                 NoSeriesMgt.InitSeries(Setup."Customer Nos.",xRec."No. Series",0D,"No.","No. Series");
               END;
             END;
  }
  
  FIELDS
  {
    { 50000;Custom Field;Text30; }
  }
}

Modern AL extension approach:

// Modern AL extension pattern (current versions)
tableextension 50000 "Customer Enhancement" extends Customer
{
    fields
    {
        field(50000; "Custom Field"; Text[30])
        {
            Caption = 'Custom Field';
            DataClassification = CustomerContent;
        }
        field(50001; "Enhanced Rating"; Enum "Customer Rating Enhancement")
        {
            Caption = 'Enhanced Rating';
            DataClassification = CustomerContent;
        }
    }
    
    trigger OnAfterInsert()
    var
        CustomLogic: Codeunit "Custom Customer Logic";
    begin
        CustomLogic.ProcessNewCustomer(Rec);
    end;
}

// Separate codeunit for business logic
codeunit 50000 "Custom Customer Logic"
{
    procedure ProcessNewCustomer(var Customer: Record Customer)
    var
        SalesSetup: Record "Sales & Receivables Setup";
        NoSeriesMgt: Codeunit NoSeriesManagement;
    begin
        if Customer."No." = '' then begin
            SalesSetup.Get();
            NoSeriesMgt.InitSeries(SalesSetup."Customer Nos.", Customer."No. Series", 0D, Customer."No.", Customer."No. Series");
        end;
        
        // Additional custom logic with proper error handling
        InitializeCustomFields(Customer);
    end;
    
    local procedure InitializeCustomFields(var Customer: Record Customer)
    begin
        if Customer."Enhanced Rating" = Customer."Enhanced Rating"::" " then
            Customer."Enhanced Rating" := Customer."Enhanced Rating"::Standard;
    end;
}

Pre-Upgrade Assessment and Planning

Comprehensive System Analysis

Customization inventory and impact assessment:

-- Analyze modified objects in NAV/BC v14 database
SELECT 
    [Object Type],
    [Object ID],
    [Object Name],
    [Modified],
    [Version List],
    [Date],
    [Time]
FROM [Object]
WHERE [Modified] = 1
    AND [Object Type] IN (1, 3, 5, 8, 50) -- Tables, Pages, Codeunits, Reports, Query
ORDER BY [Object Type], [Object ID];

-- Identify custom tables and fields
SELECT 
    [Table No_],
    [No_],
    [Field Name],
    [Type],
    [Len]
FROM [Field]
WHERE [Table No_] >= 50000 OR [No_] >= 50000
ORDER BY [Table No_], [No_];

Third-party solution compatibility analysis:

# PowerShell script for extension compatibility checking
$ExtensionPath = "C:\Extensions\V14"
$CompatibilityReport = @()

Get-ChildItem -Path $ExtensionPath -Filter "*.app" | ForEach-Object {
    $ExtensionInfo = Get-NAVAppInfo -Path $_.FullName
    
    $CompatibilityCheck = @{
        Name = $ExtensionInfo.Name
        Version = $ExtensionInfo.Version
        Publisher = $ExtensionInfo.Publisher
        TargetVersion = $ExtensionInfo.Application
        CompatibilityStatus = Test-ExtensionCompatibility -Extension $_.FullName
    }
    
    $CompatibilityReport += New-Object PSObject -Property $CompatibilityCheck
}

$CompatibilityReport | Export-Csv "ExtensionCompatibility.csv" -NoTypeInformation

Data Migration Strategy Development

Migration approach selection based on customization complexity:

| Customization Level | Recommended Approach | Estimated Timeline | Technical Complexity | |-------------------|---------------------|-------------------|-------------------| | Minimal (< 10 objects) | Direct upgrade with TXT2AL conversion | 4-6 weeks | Low | | Moderate (10-50 objects) | Staged migration with code refactoring | 8-12 weeks | Medium | | Extensive (50+ objects) | Complete rewrite using modern patterns | 16-24 weeks | High | | ISV-dependent | Vendor-managed migration with coordination | 12-20 weeks | Variable |

Technical Upgrade Implementation

Code Modernization Process

C/AL to AL conversion methodology:

# Automated C/AL to AL conversion process
$SourcePath = "C:\NAV\Objects"
$OutputPath = "C:\BC\AL\Source"

# Export objects from NAV database
Export-NAVApplicationObject -DatabaseServer "NAVServer" -DatabaseName "NAVDatabase" -Path "$SourcePath\Objects.txt"

# Convert using TXT2AL tool
Invoke-TXT2AL -Source "$SourcePath\Objects.txt" -Destination $OutputPath -Rename

# Post-conversion cleanup and modernization
Get-ChildItem -Path $OutputPath -Filter "*.al" -Recurse | ForEach-Object {
    $Content = Get-Content $_.FullName
    
    # Apply modernization patterns
    $Content = $Content -replace 'OBJECT\s+(\w+)\s+(\d+)\s+(.+)', '$1 $2 "$3"'
    $Content = $Content -replace 'BEGIN\s*$', 'begin'
    $Content = $Content -replace 'END\s*$', 'end'
    
    # Update deprecated patterns
    $Content = $Content -replace 'FORM', 'Page'
    $Content = $Content -replace 'DATAPORT', 'XMLport'
    
    Set-Content -Path $_.FullName -Value $Content
}

Advanced AL refactoring for modern patterns:

// Modernized error handling and validation
codeunit 50001 "Modern Customer Validation"
{
    procedure ValidateCustomerData(var Customer: Record Customer): Boolean
    var
        ValidationErrors: List of [Text];
        ErrorMessage: Text;
    begin
        ClearLastError();
        
        if not ValidateRequiredFields(Customer, ValidationErrors) then begin
            ErrorMessage := CreateValidationErrorMessage(ValidationErrors);
            Error(ErrorMessage);
        end;
        
        if not ValidateBusinessRules(Customer, ValidationErrors) then begin
            ErrorMessage := CreateValidationErrorMessage(ValidationErrors);
            Error(ErrorMessage);
        end;
        
        exit(true);
    end;
    
    local procedure ValidateRequiredFields(Customer: Record Customer; var ValidationErrors: List of [Text]): Boolean
    var
        HasErrors: Boolean;
    begin
        if Customer.Name = '' then begin
            ValidationErrors.Add('Customer name is required');
            HasErrors := true;
        end;
        
        if Customer."Customer Posting Group" = '' then begin
            ValidationErrors.Add('Customer posting group is required');
            HasErrors := true;
        end;
        
        exit(not HasErrors);
    end;
    
    local procedure ValidateBusinessRules(Customer: Record Customer; var ValidationErrors: List of [Text]): Boolean
    var
        ExistingCustomer: Record Customer;
        HasErrors: Boolean;
    begin
        // Duplicate VAT registration check
        if Customer."VAT Registration No." <> '' then begin
            ExistingCustomer.SetRange("VAT Registration No.", Customer."VAT Registration No.");
            ExistingCustomer.SetFilter("No.", '<>%1', Customer."No.");
            if not ExistingCustomer.IsEmpty then begin
                ValidationErrors.Add(StrSubstNo('VAT Registration No. %1 already exists', Customer."VAT Registration No."));
                HasErrors := true;
            end;
        end;
        
        exit(not HasErrors);
    end;
    
    local procedure CreateValidationErrorMessage(ValidationErrors: List of [Text]): Text
    var
        ErrorBuilder: TextBuilder;
        ErrorText: Text;
        i: Integer;
    begin
        ErrorBuilder.Append('Validation failed with the following errors:\');
        
        for i := 1 to ValidationErrors.Count do begin
            ValidationErrors.Get(i, ErrorText);
            ErrorBuilder.AppendLine(StrSubstNo('- %1', ErrorText));
        end;
        
        exit(ErrorBuilder.ToText());
    end;
}

Database Migration and Transformation

Schema migration with data integrity preservation:

-- Pre-migration data integrity verification
CREATE PROCEDURE ValidateDataIntegrity
AS
BEGIN
    DECLARE @ErrorCount INT = 0;
    DECLARE @ValidationResults TABLE (
        TableName NVARCHAR(128),
        ValidationRule NVARCHAR(256),
        ViolationCount INT
    );
    
    -- Check referential integrity
    INSERT INTO @ValidationResults
    SELECT 'Customer', 'Missing Customer Posting Group', COUNT(*)
    FROM [CRONUS$Customer]
    WHERE [Customer Posting Group] = ''
        OR [Customer Posting Group] NOT IN (SELECT [Code] FROM [CRONUS$Customer Posting Group]);
    
    -- Check required fields
    INSERT INTO @ValidationResults
    SELECT 'Customer', 'Missing Customer Name', COUNT(*)
    FROM [CRONUS$Customer]
    WHERE [Name] = '';
    
    -- Check data type constraints
    INSERT INTO @ValidationResults
    SELECT 'Customer', 'Invalid Credit Limit', COUNT(*)
    FROM [CRONUS$Customer]
    WHERE TRY_CAST([Credit Limit (LCY)] AS DECIMAL(18,2)) IS NULL;
    
    SELECT * FROM @ValidationResults WHERE ViolationCount > 0;
    
    SELECT @ErrorCount = SUM(ViolationCount) FROM @ValidationResults;
    
    IF @ErrorCount > 0
        THROW 50001, 'Data integrity violations detected. Review and resolve before proceeding.', 1;
END;

Custom field migration with type conversion:

// Data migration codeunit for complex transformations
codeunit 50002 "Advanced Data Migration"
{
    procedure MigrateCustomerEnhancements()
    var
        SourceCustomer: Record "V14 Customer";
        TargetCustomer: Record Customer;
        MigrationLog: Record "Migration Log Entry";
        ProcessedCount: Integer;
        ErrorCount: Integer;
    begin
        SourceCustomer.Reset();
        if SourceCustomer.FindSet() then
            repeat
                if MigrateCustomerRecord(SourceCustomer, TargetCustomer) then begin
                    ProcessedCount += 1;
                    LogMigrationSuccess(SourceCustomer."No.", ProcessedCount);
                end else begin
                    ErrorCount += 1;
                    LogMigrationError(SourceCustomer."No.", GetLastErrorText());
                end;
            until SourceCustomer.Next() = 0;
            
        Message('Migration completed. Processed: %1, Errors: %2', ProcessedCount, ErrorCount);
    end;
    
    local procedure MigrateCustomerRecord(Source: Record "V14 Customer"; var Target: Record Customer): Boolean
    var
        CustomerEnhancement: Record "Customer Enhancement";
    begin
        ClearLastError();
        
        if not Target.Get(Source."No.") then
            exit(false);
            
        // Migrate custom fields with transformation
        Target."Custom Field" := ConvertLegacyField(Source."Legacy Custom Field");
        Target."Enhanced Rating" := ConvertCustomerRating(Source."Old Rating System");
        
        if Target.Modify(true) then begin
            // Create related enhancement record
            CustomerEnhancement.Init();
            CustomerEnhancement."Customer No." := Target."No.";
            CustomerEnhancement."Migration Date" := Today;
            CustomerEnhancement."Source Version" := 'v14';
            CustomerEnhancement.Insert(true);
            
            exit(true);
        end;
        
        exit(false);
    end;
    
    local procedure ConvertCustomerRating(OldRating: Text[10]): Enum "Customer Rating Enhancement"
    begin
        case UpperCase(OldRating) of
            'A', 'EXCELLENT':
                exit("Customer Rating Enhancement"::Premium);
            'B', 'GOOD':
                exit("Customer Rating Enhancement"::Standard);
            'C', 'AVERAGE':
                exit("Customer Rating Enhancement"::Basic);
            else
                exit("Customer Rating Enhancement"::Standard);
        end;
    end;
}

Advanced Integration and API Modernization

Web Service and API Enhancement

Modernizing NAV web services to Business Central APIs:

// Legacy web service pattern replacement
page 50100 "Customer API v2.0"
{
    APIPublisher = 'company';
    APIGroup = 'customers';
    APIVersion = 'v2.0';
    EntityName = 'customerEnhanced';
    EntitySetName = 'customersEnhanced';
    SourceTable = Customer;
    DelayedInsert = true;
    ODataKeyFields = SystemId;
    
    layout
    {
        area(Content)
        {
            repeater(Records)
            {
                field(id; Rec.SystemId)
                {
                    Caption = 'ID';
                    Editable = false;
                }
                field(number; Rec."No.")
                {
                    Caption = 'Number';
                }
                field(displayName; Rec.Name)
                {
                    Caption = 'Display Name';
                }
                field(email; Rec."E-Mail")
                {
                    Caption = 'Email';
                }
                field(customRating; Rec."Enhanced Rating")
                {
                    Caption = 'Customer Rating';
                }
                field(creditLimit; Rec."Credit Limit (LCY)")
                {
                    Caption = 'Credit Limit';
                }
                field(lastModifiedDateTime; Rec.SystemModifiedAt)
                {
                    Caption = 'Last Modified Date Time';
                    Editable = false;
                }
            }
        }
    }
    
    trigger OnAfterGetRecord()
    begin
        SetCalculatedFields();
    end;
    
    local procedure SetCalculatedFields()
    var
        CustomerStats: Record "Cust. Ledger Entry";
    begin
        // Calculated fields for API response enhancement
        CustomerStats.SetRange("Customer No.", Rec."No.");
        CustomerStats.CalcSums("Amount (LCY)");
        // Additional calculated field logic
    end;
}

External System Integration Updates

Modernized integration patterns with proper error handling:

// Advanced integration manager with retry logic and monitoring
codeunit 50003 "Modern Integration Manager"
{
    var
        HttpClient: HttpClient;
        TelemetryLogger: Codeunit "Telemetry Logger";
    
    procedure SyncCustomerToExternalSystems(CustomerNo: Code[20]): Boolean
    var
        Customer: Record Customer;
        IntegrationConfig: Record "Integration Configuration";
        SyncResult: Boolean;
    begin
        if not Customer.Get(CustomerNo) then
            exit(false);
            
        IntegrationConfig.SetRange("Table ID", Database::Customer);
        IntegrationConfig.SetRange(Enabled, true);
        
        if IntegrationConfig.FindSet() then
            repeat
                SyncResult := ProcessIntegration(Customer, IntegrationConfig);
                LogIntegrationResult(CustomerNo, IntegrationConfig.Code, SyncResult);
            until IntegrationConfig.Next() = 0;
            
        exit(SyncResult);
    end;
    
    local procedure ProcessIntegration(Customer: Record Customer; Config: Record "Integration Configuration"): Boolean
    var
        JsonPayload: JsonObject;
        ResponseText: Text;
        RetryCount: Integer;
        MaxRetries: Integer;
    begin
        MaxRetries := 3;
        JsonPayload := BuildCustomerJson(Customer, Config);
        
        repeat
            if TrySendIntegrationRequest(Config."Endpoint URL", JsonPayload, ResponseText) then begin
                TelemetryLogger.LogSuccess('Customer Integration', Customer."No.", Config.Code);
                exit(true);
            end else begin
                RetryCount += 1;
                if RetryCount < MaxRetries then
                    Sleep(1000 * RetryCount); // Exponential backoff
            end;
        until RetryCount >= MaxRetries;
        
        TelemetryLogger.LogFailure('Customer Integration', Customer."No.", Config.Code, GetLastErrorText());
        exit(false);
    end;
    
    [TryFunction]
    local procedure TrySendIntegrationRequest(EndpointUrl: Text; Payload: JsonObject; var Response: Text)
    var
        HttpRequest: HttpRequestMessage;
        HttpResponse: HttpResponseMessage;
        HttpContent: HttpContent;
        PayloadText: Text;
    begin
        Payload.WriteTo(PayloadText);
        HttpContent.WriteFrom(PayloadText);
        
        HttpRequest.Method := 'POST';
        HttpRequest.SetRequestUri(EndpointUrl);
        HttpRequest.Content := HttpContent;
        HttpRequest.Headers.Add('Content-Type', 'application/json');
        HttpRequest.Headers.Add('Authorization', GetAuthorizationHeader());
        
        HttpClient.Send(HttpRequest, HttpResponse);
        
        if not HttpResponse.IsSuccessStatusCode then
            Error('Integration failed with status: %1', HttpResponse.HttpStatusCode);
            
        HttpResponse.Content.ReadAs(Response);
    end;
}

Testing and Validation Framework

Comprehensive Testing Strategy

Automated regression testing for upgraded functionality:

// Comprehensive test suite for upgrade validation
codeunit 50150 "Upgrade Validation Tests"
{
    Subtype = Test;
    
    var
        Assert: Codeunit Assert;
        LibraryTestInitialize: Codeunit "Library - Test Initialize";
    
    [Test]
    procedure TestCustomerCreationWithEnhancements()
    var
        Customer: Record Customer;
        CustomerValidation: Codeunit "Modern Customer Validation";
        TestCustomerNo: Code[20];
    begin
        // [GIVEN] A new customer with enhanced fields
        Initialize();
        TestCustomerNo := CreateTestCustomer();
        
        // [WHEN] Customer is validated and created
        Customer.Get(TestCustomerNo);
        
        // [THEN] All enhanced fields are properly initialized
        Assert.AreNotEqual('', Customer."Custom Field", 'Custom field should be initialized');
        Assert.AreNotEqual(Customer."Enhanced Rating"::" ", Customer."Enhanced Rating", 'Enhanced rating should be set');
        Assert.IsTrue(CustomerValidation.ValidateCustomerData(Customer), 'Customer should pass validation');
    end;
    
    [Test]
    procedure TestLegacyDataMigration()
    var
        SourceCustomer: Record "V14 Customer";
        TargetCustomer: Record Customer;
        DataMigration: Codeunit "Advanced Data Migration";
        TestSourceNo: Code[20];
    begin
        // [GIVEN] Legacy customer data
        Initialize();
        TestSourceNo := CreateLegacyTestCustomer();
        
        // [WHEN] Migration is executed
        SourceCustomer.Get(TestSourceNo);
        DataMigration.MigrateCustomerRecord(SourceCustomer, TargetCustomer);
        
        // [THEN] Data is correctly transformed
        Assert.AreEqual(SourceCustomer."No.", TargetCustomer."No.", 'Customer number should match');
        Assert.AreNotEqual('', TargetCustomer."Custom Field", 'Custom field should be migrated');
    end;
    
    [Test]
    procedure TestAPIFunctionality()
    var
        CustomerAPI: TestPage "Customer API v2.0";
        ResponseJson: JsonObject;
        TestCustomerNo: Code[20];
    begin
        // [GIVEN] A customer for API testing
        Initialize();
        TestCustomerNo := CreateTestCustomer();
        
        // [WHEN] API is called
        CustomerAPI.OpenView();
        CustomerAPI.Filter.SetFilter(number, TestCustomerNo);
        
        // [THEN] API returns correct data structure
        Assert.IsTrue(CustomerAPI.First(), 'Customer should be found via API');
        Assert.AreEqual(TestCustomerNo, CustomerAPI.number.Value, 'API should return correct customer number');
    end;
    
    local procedure Initialize()
    begin
        LibraryTestInitialize.OnTestInitialize(Codeunit::"Upgrade Validation Tests");
        // Additional initialization logic
    end;
    
    local procedure CreateTestCustomer(): Code[20]
    var
        Customer: Record Customer;
    begin
        Customer.Init();
        Customer."No." := LibraryUtility.GenerateGUID();
        Customer.Name := 'Test Customer ' + Customer."No.";
        Customer."Enhanced Rating" := Customer."Enhanced Rating"::Standard;
        Customer.Insert(true);
        exit(Customer."No.");
    end;
}

Performance and Load Testing

System performance validation after upgrade:

// Performance testing and monitoring
codeunit 50151 "Performance Validation Suite"
{
    procedure ValidateUpgradePerformance(): Boolean
    var
        PerformanceCounters: Record "Performance Counter";
        StartTime: DateTime;
        EndTime: DateTime;
        Duration: Duration;
        PerformanceThreshold: Duration;
    begin
        PerformanceThreshold := 30000; // 30 seconds
        
        // Test critical business processes
        StartTime := CurrentDateTime;
        ExecuteCriticalBusinessProcesses();
        EndTime := CurrentDateTime;
        
        Duration := EndTime - StartTime;
        
        // Log performance metrics
        LogPerformanceMetric('Critical Business Processes', Duration);
        
        exit(Duration <= PerformanceThreshold);
    end;
    
    local procedure ExecuteCriticalBusinessProcesses()
    var
        Customer: Record Customer;
        SalesOrder: Record "Sales Header";
        PurchaseOrder: Record "Purchase Header";
    begin
        // Simulate typical business operations
        CreateAndProcessSalesOrder();
        CreateAndProcessPurchaseOrder();
        RunFinancialReports();
        ProcessInventoryTransactions();
    end;
    
    local procedure LogPerformanceMetric(ProcessName: Text; Duration: Duration)
    var
        PerformanceLog: Record "Performance Log";
    begin
        PerformanceLog.Init();
        PerformanceLog."Process Name" := CopyStr(ProcessName, 1, MaxStrLen(PerformanceLog."Process Name"));
        PerformanceLog."Execution Time" := Duration;
        PerformanceLog."Test Date" := Today;
        PerformanceLog."Test Time" := Time;
        PerformanceLog.Insert();
    end;
}

Post-Upgrade Optimization and Monitoring

Continuous Monitoring Framework

System health monitoring and optimization:

// Post-upgrade monitoring and optimization
codeunit 50152 "Upgrade Health Monitor"
{
    procedure DailyHealthCheck()
    var
        HealthStatus: Record "System Health Status";
    begin
        ClearPreviousStatus();
        
        CheckSystemPerformance();
        ValidateDataIntegrity();
        MonitorIntegrationHealth();
        CheckUserAdoption();
        
        GenerateHealthReport();
    end;
    
    local procedure CheckSystemPerformance()
    var
        PerformanceValidator: Codeunit "Performance Validation Suite";
        PerformanceOK: Boolean;
    begin
        PerformanceOK := PerformanceValidator.ValidateUpgradePerformance();
        
        if not PerformanceOK then
            SendPerformanceAlert();
    end;
    
    local procedure MonitorIntegrationHealth()
    var
        IntegrationLog: Record "Integration Log Entry";
        FailureRate: Decimal;
        AcceptableFailureRate: Decimal;
    begin
        AcceptableFailureRate := 5.0; // 5% failure rate threshold
        
        IntegrationLog.SetRange("Entry Date", Today);
        if not IntegrationLog.IsEmpty then begin
            IntegrationLog.CalcFields("Failure Count", "Total Count");
            if IntegrationLog."Total Count" > 0 then
                FailureRate := (IntegrationLog."Failure Count" / IntegrationLog."Total Count") * 100;
                
            if FailureRate > AcceptableFailureRate then
                SendIntegrationAlert(FailureRate);
        end;
    end;
    
    local procedure CheckUserAdoption()
    var
        UserSession: Record "User Session";
        AdoptionMetrics: Record "User Adoption Metrics";
    begin
        // Monitor user adoption patterns
        CalculateAdoptionMetrics();
        
        // Alert if adoption is below expected levels
        if GetAdoptionRate() < 80 then
            SendAdoptionAlert();
    end;
}

The upgrade from Business Central v14 to modern releases requires comprehensive technical planning, systematic code modernization, and ongoing optimization. Success depends on understanding the architectural changes, properly migrating customizations to extension-based development, and implementing robust testing and monitoring frameworks.

This transformation enables organizations to leverage modern cloud capabilities, enhanced integration options, and improved user experiences while maintaining business continuity and preserving essential customizations developed over years of NAV and Business Central usage.