The Complete Guide to Business Central Extension Development

What are Install Codeunits?

When Install Code Runs

Install Codeunit Structure

Install Triggers Explained

1. OnInstallAppPerCompany()

2. OnInstallAppPerDatabase()

Real-World Example: E-Document Setup

Best Practices for Install Codeunits

1. Detect Fresh Install vs. Reinstall

2. Use Defensive Coding

3. Keep Install Codeunits Independent

4. Choose the Right Trigger

What are Upgrade Codeunits?

When Upgrade Code Runs

Upgrade Codeunit Structure

Upgrade Triggers Explained

Phase 1: Precondition Checks

Phase 2: Upgrade Execution

Phase 3: Validation

Real-World Example: VAT Group Upgrade

Best Practices for Upgrade Codeunits

1. Always Use Upgrade Tags

2. Add Safety Checks

3. Avoid Blank Modifies

4. Use DataTransfer for Large Tables

Why Use Upgrade Tags?

The Three-Step Pattern

Step 1: Check and Execute in Upgrade Codeunit

Step 2: Register Tag for New Companies

Step 3: Handle Fresh Installs

Complete Example: E-Document URL Migration

Upgrade Tag Naming Convention

ModuleInfo and Version Detection

Available Properties

Detecting Fresh Install vs. Reinstall

Version-Specific Upgrade Logic

DataTransfer Object

Basic Syntax

Same Table Field Migration

Cross-Table Data Migration

Performance Comparison

Protecting Code During Upgrade

Using ExecutionContext

Execution Context Values

Practical Example

Debugging Install and Upgrade Code

Setup for Debugging

Common Debugging Issues

Force Upgrade for Testing

Scenario 1: Migrate Field Data

Scenario 2: Populate New Required Field

Scenario 3: Convert Text to Option/Enum

Scenario 4: Delete Obsolete Data

Scenario 5: Multi-Version Upgrade Path

Key Concepts to Memorize

Install Codeunits

Upgrade Codeunits

Upgrade Tags

Common Exam Questions

Practice Scenarios

Scenario 1

Scenario 2

Scenario 3

Scenario 4

Microsoft Learn Documentation

Base Application Examples

What is the CSP Program?

Partner Responsibilities

Customer Benefits

Accessing the Admin Center

Environment Management

Sandbox vs Production

Trial Extensions

Database Export

Authentication Setup

API Structure and Versioning

Environment Management via API

Telemetry API

Real-World Example: Retrieving Environment Info

What are Automation APIs?

Authentication and Authorization

API Namespace and Discovery

Available Automation Endpoints

Creating Companies via API

Company Structure and Properties

Real-World Example: Company Creation

What are Configuration Packages?

RapidStart Technology

Package Lifecycle: Create, Upload, Import, Apply

Real-World Example: Automating Package Deployment

Code Deep Dive: Configuration Package API

Extension Lifecycle

Installing Extensions

Uninstalling Extensions

Extension Upload and Deployment

Monitoring Extension Deployment Status

Real-World Example: Extension Management

Code Deep Dive: Extension Management Codeunit

User Management via API

Permission Sets

Security Groups (APIV2)

User Synchronization

Real-World Example: User Provisioning

Job Queue Management

Scheduled Jobs API

Monitoring Job Status

What is Telemetry?

Azure Application Insights Integration

Environment Lifecycle Telemetry

Configuring Telemetry via API

Key Telemetry Signals

In-Client Performance Profiler

Business Central Performance Toolkit (BCPT)

BCPT Suite Configuration

Analyzing Performance Telemetry

Real-World Example: BCPT Scenario

Automated Tenant Provisioning

Environment Standardization

CI/CD Integration

Complete Workflow Example

API Error Responses

Async Operation Handling

Retry Logic

Rate Limiting

Scenario 1: Clone Production to Sandbox

Scenario 2: Bulk User Permission Update

Scenario 3: Monitor Extension Deployment Across Multiple Companies

Scenario 4: Automated Nightly Configuration Backup

Key Concepts to Memorize

Cloud Solution Provider (CSP)

Admin Center

Admin Center API

Automation APIs

Configuration Packages

Extension Management

Users and Permissions

Telemetry

Performance

Common Exam Questions

Exercise 1: Create Company via API

Exercise 2: Monitor Extension Installation

Exercise 3: Bulk Permission Assignment

Practice Questions

Microsoft Learn Documentation

Blog Posts

Video Resources

Base Application Examples

Why Performance Testing Matters

Performance Testing vs Functional Testing

Common Performance Issues

Performance Testing Personas

What is the Performance Toolkit?

BCPT Architecture

The Three BCPT Components

Prerequisites and Requirements

Installing the VS Code Extension

Setting Up Your First Project

Connecting to Your Environment

Installing Sample Tests

Test Codeunit Structure

Normal Subtype Tests

Test Subtype Tests (UI Scenarios)

The BCPT Test Context

Measuring Scenarios with StartScenario and EndScenario

Simulating User Behavior with UserWait

Real-World Example: Create Sales Order

Why Use Parameters?

Implementing the BCPT Test Param Provider Interface

GetDefaultParameters Method

ValidateParameters Method

Using Parameters in Test Logic

Real-World Example: Purchase Order with N Lines

Understanding BCPT Suites

Suite Configuration Settings

Adding Test Lines to Suites

User Delay Configuration

Delay Between Iterations

Tags for Comparison Testing

Real-World Example: 50-User Trading Scenario

Single Run Mode

Full Suite Execution

Running from VS Code

Running via PowerShell

Background vs Foreground Execution

Monitoring Test Progress

Understanding Result Metrics

Baseline Comparison

SQL Statement Analysis

Duration Analysis

Identifying Performance Regressions

Log Entries and Drill-Down

Exporting Results to Excel

Enabling Azure Application Insights

BCPT Telemetry Signals

Installing the Power BI Performance Report

KQL Queries for Performance Analysis

Creating Custom Dashboards

Establishing Baselines

Before and After Testing

Version Upgrade Testing

Extension Impact Analysis

Real-World Example: Detecting Extension Regression

Multi-Session Testing

Workload Simulation Patterns

Testing with Different Data Volumes

Concurrent User Simulation

Deadline-Based Testing

Performance Profiling Integration

AL-Go for GitHub Integration

Azure DevOps Integration

Automated Performance Gates

Continuous Performance Monitoring

Real-World Example: GitHub Actions Workflow

Test Design Best Practices

Suite Configuration Best Practices

Data Management Best Practices

Analysis Best Practices

Common Pitfalls to Avoid

Common Errors and Solutions

Performance Test Failures

Connection Issues

Debugging Test Scenarios

Key Concepts to Memorize

Common Exam Questions

Practice Scenarios for Exam

Exercise 1: Creating Your First Test Scenario

Exercise 2: Parameterized Testing

Exercise 3: Regression Detection

Exercise 4: Multi-User Load Testing

Practice Questions

Answers to Practice Questions

Microsoft Documentation

GitHub Resources

Community Resources

Why Migrate to the Cloud?

Migration vs New Implementation

Supported Source Systems

Cloud Migration Benefits

How the Migration Tool Works

Data Replication Pipeline

Azure Data Factory Integration

Integration Runtime Components

Change Tracking Mechanism

System Requirements

License Requirements

Network Requirements

User Permissions

Database Prerequisites

Data Cleanup Recommendations

Company Selection Strategy

Extension Migration Planning

Storage Capacity Planning

Advanced Multi-Stage Strategy

Migration Timeline Best Practices

Step 1: Sign In to Microsoft 365

Step 2: Access Business Central Online

Step 3: Run Cloud Migration Setup

Step 4: Accept Terms and Conditions

Step 5: Product Selection

Step 6: SQL Connection Setup

Step 7: Integration Runtime Installation

Step 8: SQL Connection String

Step 9: Select Companies to Migrate

9.2 Finishing the Setup

10.1 The Cloud Migration Management Page

10.2 Running the Initial Migration

Starting the Initial Migration

Migration Phases

What Happens During Migration

10.3 Monitoring Migration Progress

Real-Time Monitoring Options

10.4 Migration Logs and Diagnostics

Accessing Migration Logs

Diagnostic Tools

10.5 Handling Migration Errors

Error Handling Strategy

Common Error Scenarios and Solutions

10.6 Running Incremental Migrations

What Are Incremental Migrations?

Running an Incremental Migration

Scheduling Automatic Incremental Migrations

11.1 When Data Upgrade Is Required

11.2 Running the Data Upgrade

11.3 Post-Upgrade Validation

12.1 Planning the Cutover

12.2 Running the Final Migration

12.3 Cutover Validation

12.4 Go-Live

12.5 Disabling Cloud Migration

13.1 User Setup and Permissions

13.2 Record Links and Attachments

13.3 Integration Setup

13.4 Report Layouts and Customizations

13.5 Job Queue and Scheduled Tasks

14.1 Setup and Configuration Issues

Issue: Cannot Access Cloud Migration Setup

Issue: Source Product Not Listed in Setup

14.2 Integration Runtime Issues

Issue: Integration Runtime Installation Fails

Issue: Integration Runtime Won’t Register

Issue: Integration Runtime Shows “Stopped” or “Disconnected”

14.3 Connection and Authentication Errors

Issue: Cannot Connect to Source SQL Server

Issue: SQL Authentication Fails

14.4 Data Replication Errors

Issue: Change Tracking Not Enabled

Issue: Table Replication Times Out

Issue: Schema Mismatch Errors

14.5 Performance Issues

Issue: Migration Taking Too Long

15.1 Planning Best Practices

15.2 Technical Best Practices

15.3 Migration Execution Best Practices

15.4 Testing Best Practices

15.5 Common Pitfalls to Avoid

17.1 Key Concepts to Memorize

17.2 Common Exam Question Topics

17.3 Sample Exam-Style Questions (Practice)

17.4 Study Tips

Exercise 1: Planning a Cloud Migration

Exercise 2: Configuring Migration Setup

Exercise 3: Running and Monitoring Migration

Exercise 4: Troubleshooting Migration Issues

Practice Questions (20 Questions)

Detailed Answers to Practice Questions

What is a Company?

Companies vs. Environments

When to Create Multiple Companies

Prerequisites and Permissions

The Create New Company Wizard

Company Templates Explained

Step-by-Step Company Creation

Creating Companies via the Automation API

Company Information Page

Assisted Company Setup Wizard

General Ledger Setup

Area-Specific Setup Pages

What are Configuration Packages?

The Configuration Worksheet

Creating a Configuration Package

Exporting and Importing Packages

Applying Configuration Packages

Best Practices for Configuration Packages

When to Copy a Company

Performance Considerations

The Copy Process

Limitations and Gotchas

The ChangeCompany Method

CompanyName() Function

Working with Company Records

Real-World Code Examples

Understanding Intercompany

Setting Up Intercompany Partners

Intercompany Chart of Accounts

Posting Intercompany Transactions

Managing the Intercompany Inbox/Outbox

What is Contoso Coffee?

Installing Demo Data

Available Modules

Renaming Companies

Deleting Companies

Company Badges

User Access and Permissions

Exercise 1: Create a Company with Production Data

Exercise 2: Create and Apply a Configuration Package

Exercise 3: Using ChangeCompany in AL Code

Exercise 4: Set Up Intercompany Transactions

Key Concepts to Know

Common Exam Scenarios

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

Question 9

Question 10

Question 11

Question 12

Question 13

Question 14

Question 15

Question 16

Question 17

Question 18

Question 19

Question 20

Answer 1

Answer 2

Answer 3

Answer 4

Answer 5

Answer 6

Answer 7

Answer 8

Answer 9

Answer 10

Answer 11

Answer 12

Answer 13

Answer 14

Answer 15

Answer 16

Answer 17

Answer 18

Answer 19

Answer 20

Microsoft Learn Documentation

Video Reference

Base Application Code Examples

What is the Business Central Outlook Add-in?

Add-in Components

1. Contact Insights Add-in

2. Document View Add-in

System Requirements

Supported Outlook Versions

Method 1: Centralized Deployment (Recommended)

Method 2: Individual User Installation

Method 3: Manual Installation (On-Premises)

Choosing the Right Deployment Method

Exchange Online Configuration

Exchange Server Configuration

Microsoft Entra ID Setup

Business Central Server Configuration

Nested App Authentication (NAA)

Contact Insights Features

Document View Features

Creating Documents from Outlook

Managing Incoming Documents

File Attachments

Updating Outlook

Installing WebView2

Browser Requirements

Performance Best Practices

Understanding the Add-in Architecture

Manifest Management

Microsoft Graph API Integration

Exchange Web Services

Real-World Code Example: Outlook Add-In Services

Real-World Code Example: Exchange Add-in Setup

Switching Between Environments

Working with Multiple Companies

Customizing for Multiple Environments

Common Issues and Solutions

Add-in Not Starting

Authentication Problems

Page Not Supported Errors

Shared Mailbox Limitations

Excel Add-in Integration

Teams Integration

Power BI Integration

Key Concepts to Memorize

Outlook Add-in Components

Deployment Methods

Requirements

Technical Configuration

Common Exam Questions

Exercise 1: Deploy the Outlook Add-in via Centralized Deployment

Exercise 2: Create a Sales Quote from Outlook

Exercise 3: Process Incoming Documents from Outlook

Exercise 4: Configure Outlook Add-in for Multiple Environments

Microsoft Learn Documentation

Base Application Code References

Video Resources

What is the Business Central App for Teams?

Integration Components

1. Interactive Cards

2. Contact Search

3. Share to Teams

4. Business Central Tabs

System Requirements

Licensing Requirements

Method 1: Direct Link Installation

Method 2: From Teams App Store

Method 3: From Business Central

Centralized Deployment for Organizations

Understanding Business Central Cards

Sharing Records in Conversations

Using Share to Teams

Viewing Card Details

Card Data Visibility Settings

Command Box Search

Message Compose Box Search

Contact Card Features

Viewing Interactions and Documents

Adding Tabs from Recommended Content

Adding Tabs Using Page Links

Managing and Customizing Tabs

Tab Permissions and Access

Accessing Settings

Switching Companies and Environments

Working with Multiple Companies

Managing Teams Integration

URL Previews Policy

Privacy and Compliance

Information Barriers and DLP

Understanding the Integration Architecture

Extending Teams Cards

Approach 1: Field Groups (Recommended)

Approach 2: Event Subscribers

Customizing Card Fields with Events

Adding Recommended Content to Tabs

Real-World Code Example: Teams Customizations

Page Summary Provider

Page Action Provider

Sharing Cards with Guests

Guest Experience Differences

Guest App Installation

Common Issues and Solutions

Links Not Expanding into Cards

Authentication and Sign-in Issues

Tab Visibility Problems

Language and Localization Issues

Outlook Integration

Excel Add-in Integration

Power BI Integration

Key Concepts to Memorize

Integration Components

Installation Methods

Requirements

Developer Events

Common Exam Questions

Exercise 1: Install and Configure the Business Central App for Teams

Exercise 2: Share Business Central Records and Create a Tab

Exercise 3: Extend Teams Cards with Custom Fields

Exercise 4: Configure Recommended Content for Teams Tabs

Microsoft Learn Documentation

Microsoft Learn Training

Code Examples

Video Resources

What is a Table?

Table Architecture Overview

Table Types

1. Normal Tables

2. Temporary Tables

3. System Tables

4. Virtual Tables

System Fields

Table Syntax and Structure

Table Properties

Field Definition and Properties

Data Types in AL

Simple Data Types

Text Data Types

Complex Data Types

Field Classes: Normal, FlowField, and FlowFilter

Normal Fields

FlowFields

FlowFilter Fields

Data Classification

Using Snippets for Table Creation

Understanding Primary Keys

Secondary Keys

Clustered vs Non-Clustered Keys

Clustered Index

Non-Clustered Index

Unique Keys

Keys with Included Fields

Columnstore Indexes

Key Performance Considerations

DropDown Field Group

Brick Field Group

Adding Field Groups in Extensions

Table-Level Triggers

Field-Level Triggers

Trigger Execution Order

Customer Table Analysis

Item Table Analysis

What is a Table Extension?

Table Extension Syntax

Adding Fields to Existing Tables

Adding Keys in Table Extensions

Adding Field Groups in Extensions

Extension Limitations and Constraints

Using Snippets for Table Extensions

Service Customer Table Extension

Subscription Billing Customer Extension

Understanding Retention Policies

Why Retention Policies Matter

Setting Up Retention Policies

Retention Period Interface

Retention Policy Filtering Interface

Retention Policy Deleting Interface

Adding Custom Tables to Retention Policies

Real-World Retention Policy Implementation

Table Design Best Practices

Key Design Best Practices

Extension Best Practices

Retention Policy Best Practices

Key Concepts to Memorize

Common Exam Questions

Exercise 1: Create a Custom Table

Exercise 2: Add Keys and Field Groups

Exercise 3: Create FlowFields

Exercise 4: Create a Table Extension

Exercise 5: Extend with Keys and Field Groups

Exercise 6: Add FlowFields to Extension

Exercise 7: Implement Table Triggers

Exercise 8: Implement Retention Policy for Custom Table

Exercise 9: Custom Retention Policy Deleting Interface

Microsoft Learn Documentation

Microsoft Learn Training Modules

Code Examples

Video Resources

What is a Page?

Page Architecture Overview

Page Types

Page vs Table Relationship

Page Syntax and Structure

Page Properties

Using Snippets for Page Creation

Areas

Groups

Fields and Controls

Parts and FactBoxes

Repeaters for List Display

Action Areas

Action Types

Action Properties

Promoted Actions

Action Groups

Page-Level Triggers

Field-Level Triggers

Action Triggers

What are Page Extensions?

Page Extension Syntax

Placement Keywords

Modifying Existing Controls

Moving Controls

Real-World Example: Customer Card Extension

Understanding Role Centers

Profile Objects

Page Customization Objects

Customization Layers

Creating Views

Views in Page Extensions

SourceTableView and Filters

RunObject vs RunPageLink

Editable and Enabled Properties

Visible Property and Dynamic UI

AboutTitle and AboutText

What is Page Scripting?

Recording Scripts

Playback and Validation

Power Fx Integration

Best Practices for Page Scripting

Scenario 1: Making a Field Required with Visual Indicator

Scenario 2: Conditional Field Visibility

Scenario 3: Running a Report from a Page Action

Scenario 4: Drill-Down to Related Records

Scenario 5: Page Part Communication

Key Concepts to Memorize

Common Exam Questions

Exercise 1: Create a Custom List Page

Exercise 2: Create a Page Extension

Exercise 3: Create a Document Page

Exercise 4: Create a Profile with Page Customization

Microsoft Learn Documentation

Microsoft Learn Training Modules

Page Scripting Resources

Video Resources

What is a Report?

Report Architecture Overview

Report Types

1. Document Reports

2. Analysis Reports

3. Processing-Only Reports

Report Properties

Report Syntax and Structure

Dataset Definition

Data Items and Columns

DataItemLink and DataItemLinkReference

Request Pages

Report Triggers

Using Snippets for Report Creation

Layout Types Overview

RDLC Layouts

Word Layouts

Excel Layouts

The Rendering Section

Multiple Layouts per Report

Custom Report Layouts

When to Use Processing-Only Reports

Processing-Only Report Examples

Customer Top 10 List Analysis

Standard Sales Invoice Analysis

Salesperson Commission Report Analysis

What is a Report Extension?

Report Extension Syntax

Adding Columns to Existing Data Items

Adding New Data Items

Modifying Data Items with Triggers

Extending Request Pages

Adding New Layouts

Report Extension Limitations

Service Document Entries Extension

Customer Top 10 with Email Extension

When to Use Substitution vs Extension

Implementing Report Substitution

Substitution Best Practices

What is a Query?

Query vs Report

Query Architecture

Query Properties

Query Syntax and Structure

Data Items in Queries

Columns and Filters

Joining Tables

Aggregation Methods

Sorting and Limiting Results

Top 10 Customer Sales Query

Top Customer Overview Query

Query-Based Report Pattern

Opening and Reading Query Data

OData Query Exposure

Query Web Service Best Practices

Report Design Best Practices

Layout Best Practices

Extension Best Practices

Query Best Practices

Performance Considerations

Key Concepts to Memorize

Common Question Patterns

Watch Out For

Exercise 1: Create a Basic Report with RDLC Layout

Exercise 2: Create a Report with Multiple Layouts

Exercise 3: Create a Processing-Only Report

Exercise 4: Create a Report Extension

Exercise 5: Create a Query with Aggregation

Exercise 6: Create a Query-Based Report

Exercise 7: Implement Report Substitution

Microsoft Learn Resources

Sample Code Repositories

Community Resources

Companion Videos

Understanding Try Functions

TryFunction Attribute

Return Values and Error Handling

Database Write Restrictions

Getting Error Details

Base Application Examples: Try Functions

Best Practices for Try Functions

Understanding Collectible Errors

ErrorBehavior Attribute

ErrorInfo Data Type

Collectible Errors API

Implementing Collectible Errors

Base Application Examples: Collectible Errors

Best Practices for Collectible Errors

Understanding RAD

The rad.json File

What RAD Includes and Excludes

RAD Keyboard Shortcuts

RAD Limitations and Warnings

Best Practices for RAD

Debugging Overview

Launch.json Configuration

Standard Debugging

Attach and Debug Next

Snapshot Debugging

Database Statistics in Debugger

Deploying Extensions

Best Practices for Debugging

Understanding the Permission Model

Permission Set Objects

Entitlement Objects

Permission Set Extensions

Base Application Examples: Permissions

Best Practices for Permissions

Understanding Inherent Permissions

InherentPermissions Attribute

InherentPermissionsScope

InherentEntitlements Property

Base Application Examples: Inherent

When to Use Inherent Permissions

Understanding Application Areas

Built-in Application Areas

Creating Custom Application Areas

Experience Tiers

ApplicationArea Property Inheritance

Best Practices for Application Areas

Error Handling (Try Functions & Collectible Errors)

RAD (Rapid Application Development)

Debugging

Permissions and Entitlements

Application Areas

Exercise 1: Implement Error Handling with Try Function

Exercise 2: Collect Multiple Validation Errors

Exercise 3: Create a Permission Set Structure

Exercise 4: Implement Inherent Permissions

Exercise 5: Create Custom Application Area

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

Question 9

Question 10

Question 11

Question 12

Question 13

Question 14

Question 15

Question 16

Question 17

Question 18

Question 19

Question 20

Answer 1: C

Answer 2: B

Answer 3: B

Answer 4: C

Answer 5: B

Answer 6: C

Answer 7: C

Answer 8: B

Answer 9: C

Answer 10: B

Answer 11: B

Answer 12: B

Answer 13: C

Answer 14: B

Answer 15: B

Answer 16: C

Answer 17: B

Answer 18: C

Answer 19: B

Answer 20: C

Microsoft Learn Documentation

Microsoft Learn Training Modules

MVP Blog Posts and Community Resources

GitHub Repositories

YouTube Resources