Customization, Extensions & Integration

Part 5 of 11 in the Business Central Implementation Series

Published: December 2025 | Reading Time: 15 minutes

Introduction

While Business Central provides extensive out-of-the-box functionality, every business has unique requirements that may not be fully addressed by standard features. This is where customization, extensions, and integrations come into play—allowing you to tailor Business Central to your specific needs while maintaining upgrade compatibility and system integrity.

The modern approach to extending Business Central has evolved significantly. Gone are the days of directly modifying base application code. Today's extensibility model, based on AL language extensions, enables powerful customization while preserving your ability to receive updates and new features from Microsoft seamlessly.

This comprehensive guide explores the full spectrum of Business Central extensibility—from understanding when customization is necessary, to developing AL extensions, leveraging AppSource applications, and integrating with external systems.

📋 When to Use AppSource vs Custom Extensions (Decision Tree)

Start Here: Do you need functionality beyond Business Central standard features?

Step 1: Search AppSource Marketplace

• Browse appsource.microsoft.com for Business Central apps

• Filter by category: Accounting, Sales, Inventory, Integration, etc.

• If FOUND: ✅ Use AppSource app (certified, supported, upgradeable)

• If NOT FOUND: Proceed to Step 2

Step 2: Can Power Platform solve it?

• Power Automate: Workflow automation, approvals, notifications → ✅ Use Power Automate

• Power Apps: Custom mobile/web apps → ✅ Build Power App with BC connector

• Power BI: Custom reporting/analytics → ✅ Create Power BI dashboard

• If NO: Proceed to Step 3

Step 3: Evaluate Customization Scope

• Minor UI changes (add field to page): ✅ Simple AL page extension

• New business logic (calculations, validations): ✅ AL codeunit/table extension

• Complex integration: ✅ AL extension with API calls

• Modify standard behavior: ✅ AL extension subscribing to events

Customization Cost Comparison:

• AppSource app: $20-$100/user/month (ongoing subscription)

• AL extension: $25,000-$100,000 one-time (plus $5K-$15K annual maintenance)

• Power Platform: Included with BC licenses or $20/user/month

Recommendation Order: AppSource → Power Platform → Custom AL Extension

💡 Pricing & Timeline Note
All cost estimates and timelines in this article reflect typical Business Central implementations as of January 2026.

• Geographic Context: Estimates based on Western Europe and North America markets

• Regional Variation: Implementation costs vary significantly by region (typically 30-60% lower in Eastern Europe, Asia-Pacific, and Latin America)

• Microsoft Licensing: Verify current prices at aka.ms/BCPricing as these change periodically

• Effort-Based Budgeting: Use the consulting hours estimates with your local partner's rates for accurate budgeting

These are reference estimates for planning purposes. Request detailed quotes from Microsoft Solutions Partners for your specific requirements.

Understanding Business Central Extensibility Model

Microsoft has built Business Central on a modern, extension-based architecture designed for cloud-first operations.

The Extension Framework

Why Extensions Matter:

Traditional ERP customization required modifying source code, creating several problems:

• Upgrade complexity and potential breakage

• Vendor support complications

• Testing burden for every update

• Code conflicts between customizations

Business Central's extension model solves these issues:

• Isolation: Extensions don't modify base code

• Upgrade Safety: Microsoft updates don't break extensions

• Maintainability: Clear separation between standard and custom

• Portability: Extensions can be installed/uninstalled cleanly

Extension Capabilities:

Extensions can:

• Add new pages, reports, and objects

• Extend existing tables with new fields

• Subscribe to events in base application

• Modify page layouts and add fields

• Create custom business logic

• Integrate with external services

• Add new APIs

Extensions cannot:

• Delete or modify base objects directly

• Override standard business logic (must use events)

• Access private methods or variables

AL Language Fundamentals

Business Central extensions are written in AL (Application Language)—a modern, structured language purpose-built for business applications.

AL Basics:

Object Types:

• Tables: Data structures for storing information

• Pages: User interface for data entry and viewing

• Reports: Document generation and data analysis

• Codeunits: Business logic containers

• Queries: Data retrieval and analysis

• XMLPorts: Data import/export

• Enums: Enumeration types for option fields

Development Environment:

• Visual Studio Code with AL Language extension

• AL Language extension provides IntelliSense, debugging, compilation

• Git or Azure DevOps for source control

• Docker containers for local development environments

Example AL Code Structure:

tableextension 50100 CustomerExt extends Customer
{
    fields
    {
        field(50100; "Customer Tier"; Option)
        {
            OptionMembers = Bronze,Silver,Gold,Platinum;
            OptionCaption = 'Bronze,Silver,Gold,Platinum';
            DataClassification = CustomerContent;
        }
        field(50101; "Loyalty Points"; Integer)
        {
            DataClassification = CustomerContent;
        }
    }
}

pageextension 50100 CustomerCardExt extends "Customer Card"
{
    layout
    {
        addafter(Name)
        {
            field("Customer Tier"; "Customer Tier")
            {
                ApplicationArea = All;
            }
            field("Loyalty Points"; "Loyalty Points")
            {
                ApplicationArea = All;
            }
        }
    }
}

Standard Customization Options vs. Custom Development

Before building custom solutions, explore configuration-based customization.

Configuration-Based Customization

Business Central offers extensive customization without code:

Page Personalization:

• Users customize their own page layouts

• Show/hide fields and columns

• Rearrange sections

• Filter and sort preferences

• Saved per user

Profile Configuration:

• Administrators design role-specific layouts

• Define default views for user groups

• Configure navigation and actions

• Embed reports and charts

Report Layouts:

• Modify existing report layouts using Word or RDLC

• Customize forms, invoices, statements

• Add logos and branding

• Adjust formatting and sections

• Multiple layouts per report for different purposes

Workflow Configuration:

• Define approval workflows without code

• Configure notification rules

• Set up automated responses

• Establish escalation procedures

Custom Report Selection:

• Assign custom layouts to documents

• Configure per-customer/vendor layouts

• Multi-language document support

When Configuration Is Enough:

• Cosmetic changes (colors, fonts, layouts)

• User interface rearrangement

• Report formatting adjustments

• Workflow routing modifications

• Role-based view customization

When Custom Development Is Needed

Indicators for Custom Development:

New Business Logic:

• Complex calculations not available in standard

• Industry-specific business rules

• Custom validation requirements

• Automated process orchestration

Additional Data Storage:

• Tracking information not in standard tables

• Related entity relationships

• Historical audit trails

• Custom categorizations

External System Integration:

• Real-time data synchronization

• API-based connectivity

• Custom file format processing

• Legacy system interfacing

Unique Reporting Needs:

• Complex data aggregation

• Custom analytical reports

• Regulatory compliance reporting

• Industry-specific documentation

Process Automation:

• Scheduled background jobs

• Triggered automation

• Cross-module orchestration

• Mass update capabilities

Creating Custom Reports and Layouts

Reports are among the most common customization needs.

Report Development Approaches:

Custom Report Layouts (No Code)

Word Layouts:

• Best for forms and documents (invoices, POs, packing slips)

• Drag-and-drop design in Word

• Use standard Word formatting

• Insert Business Central data fields

• Add images, logos, tables

• Support for multiple languages

Creating Word Layout:

1. Export existing layout as starting point

2. Open in Word

3. Modify design using Custom XML part fields

4. Save and import back to Business Central

5. Assign to report/document

RDLC Layouts:

• Best for complex analytical reports

• Pixel-perfect formatting control

• Charts, graphs, matrices

• Advanced grouping and calculations

• Created using Visual Studio Report Designer

Custom Report Development (AL Code)

When to Build Custom Reports:

• Unique data combinations not available in standard reports

• Complex calculations or algorithms

• Integration with external data

• Performance optimization for large datasets

Report Structure:

report 50100 "Custom Sales Analysis"
{
    UsageCategory = ReportsAndAnalysis;
    ApplicationArea = All;
    Caption = 'Custom Sales Analysis';
    DefaultLayout = RDLC;
    RDLCLayout = './CustomSalesAnalysis.rdl';

    dataset
    {
        dataitem(Customer; Customer)
        {
            column(No_; "No.")
            {
            }
            column(Name; Name)
            {
            }
            dataitem(SalesLine; "Sales Line")
            {
                DataItemLink = "Sell-to Customer No." = FIELD("No.");
                column(Amount; Amount)
                {
                }
                column(Quantity; Quantity)
                {
                }
            }
        }
    }

    requestpage
    {
        layout
        {
            area(content)
            {
                group(Options)
                {
                    field(DateFilter; DateFilter)
                    {
                        ApplicationArea = All;
                        Caption = 'Date Filter';
                    }
                }
            }
        }
    }
}

Best Practices:

• Start with existing similar reports

• Optimize data retrieval for performance

• Provide user-friendly parameters

• Test with production data volumes

• Document report purpose and usage

• Consider localization needs

Developing Custom Pages and Extensions

Extend user interface to support custom processes.

Page Extension Example:

Adding fields to existing pages:

pageextension 50101 ItemCardExt extends "Item Card"
{
    layout
    {
        addafter(Description)
        {
            field("Brand Name"; "Brand Name")
            {
                ApplicationArea = All;
                ToolTip = 'Brand name for this item';
            }
        }
        
        addafter("Base Unit of Measure")
        {
            field("Eco Friendly"; "Eco Friendly")
            {
                ApplicationArea = All;
            }
        }
    }

    actions
    {
        addafter(Prices)
        {
            action(CalculateMargin)
            {
                ApplicationArea = All;
                Caption = 'Calculate Margin';
                Image = Calculate;
                
                trigger OnAction()
                var
                    ItemMgt: Codeunit "Item Management";
                begin
                    ItemMgt.CalculateMargin(Rec);
                end;
            }
        }
    }
}

Custom Page Development:

Creating entirely new pages:

page 50100 "Customer Loyalty Card"
{
    PageType = Card;
    SourceTable = Customer;
    Caption = 'Customer Loyalty';

    layout
    {
        area(content)
        {
            group(General)
            {
                field("No."; "No.")
                {
                    ApplicationArea = All;
                }
                field(Name; Name)
                {
                    ApplicationArea = All;
                }
                field("Customer Tier"; "Customer Tier")
                {
                    ApplicationArea = All;
                }
            }
            group(Loyalty)
            {
                field("Loyalty Points"; "Loyalty Points")
                {
                    ApplicationArea = All;
                }
                field("Points This Year"; PointsThisYear)
                {
                    ApplicationArea = All;
                    Editable = false;
                }
            }
        }
    }
}

Integration Architecture and Options

Connect Business Central with external systems and services.

Power Platform Integration

Microsoft's Power Platform provides powerful low-code/no-code integration capabilities.

Power BI Integration:

Built-in Capabilities:

• Embedded Power BI reports in Business Central pages

• Direct connector to Business Central data

• Real-time data refresh

• Role-based report distribution

• Mobile Power BI app access

Implementation:

1. Create Power BI workspace

2. Connect to Business Central using connector

3. Build reports and dashboards

4. Publish to Power BI service

5. Embed in Business Central pages

Use Cases:

• Executive dashboards

• Sales analytics

• Financial reporting

• Operational metrics

• Predictive analytics

Power Automate Integration:

Automation Scenarios:

• Approval workflow notifications

• Document routing

• Data synchronization

• Email automation

• Social media posting

Example Flow:

Power Apps Integration:

Mobile App Development:

• Custom data entry forms

• Field service applications

• Inspection checklists

• Time tracking

• Expense reporting

Canvas Apps: Pixel-perfect custom design Model-Driven Apps: Data-centric applications

Microsoft 365 Integration

Seamless integration with Office applications.

Outlook Integration:

• Contact synchronization

• Attach Business Central documents to emails

• Track email conversations by customer

• Convert emails to sales opportunities

• Schedule follow-ups

Excel Integration:

• Edit in Excel functionality

• Export lists and reports

• Excel-based data import

• Financial report designer using Excel

• Budget worksheets

Teams Integration:

• Share Business Central records in Teams chats

• Collaborate on documents

• Search Business Central from Teams

• Notifications and alerts in Teams

• Embed Business Central tabs in Teams channels

SharePoint Integration:

• Document attachments stored in SharePoint

• Approval workflows

• Document libraries

• Version control

• Collaborative document editing

Third-Party Integrations

Connect Business Central with external applications.

Common Integration Scenarios:

CRM Integration (Salesforce, HubSpot):

• Customer and contact synchronization

• Opportunity to quote conversion

• Order status visibility

• Customer service case tracking

E-Commerce Integration (Shopify, Magento, WooCommerce):

• Product catalog synchronization

• Real-time inventory updates

• Order import from web store

• Fulfillment status updates

• Customer data synchronization

Shipping Integration (FedEx, UPS, DHL):

• Rate calculation

• Label generation

• Tracking number assignment

• Shipment status updates

• Address validation

Banking Integration:

• Bank statement import (OFX, BAI)

• Payment file export (ACH, SEPA, ISO20022)

• Positive pay file generation

• Lockbox processing

• Cash position reporting

Payment Gateway Integration (Stripe, PayPal, Authorize.net):

• Credit card processing

• Payment tokenization

• Refund processing

• Recurring billing

• Payment reconciliation

API and Web Services

Technical integration methods for system-to-system connectivity.

Business Central API Types:

OData Web Services:

• RESTful API access

• Query Business Central data

• CRUD operations (Create, Read, Update, Delete)

• Filter and search capabilities

• Paging for large datasets

SOAP Web Services:

• Legacy integration method

• Still supported for backward compatibility

• Expose pages and codeunits

• XML-based messaging

API Pages (v2.0):

• Modern RESTful APIs

• Standard endpoints for common entities

• Optimized for performance

• OAuth2 authentication

• Well-documented

Common API Entities:

• Customers, Vendors, Items

• Sales Orders, Purchase Orders, Invoices

• General Ledger Entries

• Inventory

• Financial statements

API Integration Example:

GET https://api.businesscentral.dynamics.com/v2.0/{tenant}/Production/api/v2.0/companies({companyId})/customers
Authorization: Bearer {access_token}

Response:
{
    "value": [
        {
            "id": "guid",
            "number": "10000",
            "displayName": "Adatum Corporation",
            "type": "Company",
            "email": "contact@adatum.com",
            "balance": 15000.00
        }
    ]
}

Integration Middleware:

Consider middleware platforms for complex integrations:

• Azure Logic Apps: Cloud-based integration workflows

• Azure Functions: Serverless integration code

• Dell Boomi: Enterprise integration platform

• Jitterbit: Hybrid integration solution

• MuleSoft: API-led connectivity

AppSource Extensions and Add-ons

Leverage pre-built solutions from Microsoft's marketplace.

AppSource Overview:

Microsoft AppSource offers thousands of pre-built extensions:

• Validated by Microsoft

• Maintained by vendors

• Subscription or perpetual licensing

• Often cheaper than custom development

• Regular updates and support

Popular AppSource Categories:

Industry-Specific Solutions:

• Manufacturing MES

• Retail POS

• Professional services project management

• Construction job costing

• Healthcare compliance

Functional Extensions:

• Advanced warehouse management

• EDI integration

• Quality management

• Lot traceability

• Advanced pricing

Integration Extensions:

• Salesforce connector

• Shopify integration

• Amazon marketplace

• PayPal payments

• DocuSign

Reporting and Analytics:

• Advanced financial reports

• Consolidation tools

• Budgeting and forecasting

• Management reporting

Productivity Tools:

• Document management

• Barcode scanning

• Mobile applications

• Automated workflows

Evaluating AppSource Extensions:

Selection Criteria:

• Functionality: Does it meet your requirements?

• Reviews and Ratings: What do other users say?

• Vendor Reputation: Is the vendor established and reliable?

• Support: What support options are available?

• Pricing: License cost and ongoing fees?

• Updates: How frequently is it updated?

• Dependencies: Does it require other extensions?

• Microsoft Validation: AppSource apps undergo Microsoft technical validation ensuring quality standards

Trial and Testing:

• Request trial in sandbox environment (most apps offer 30-day trials)

• Test with realistic data and scenarios

• Evaluate performance impact

• Assess user experience

• Verify documentation quality

• Test vendor support responsiveness

AppSource Certification Process (for ISVs developing extensions):

If you're building extensions for public distribution, understand Microsoft's certification requirements:

1. Technical Validation:

   • Code must use AL extension model (no base code modification)

   • Pass automated AppSource validation checks

   • Performance requirements (page load < 2 seconds, etc.)

   • Security requirements (proper data classification, OAuth, etc.)

   • Proper use of events, no hard dependencies on other ISV apps

2. Functional Validation:

   • Clear documentation and help resources

   • Intuitive user experience

   • Meaningful error messages

   • Proper localization (if multi-language)

3. Business Validation:

   • Pricing transparency

   • Clear support offerings

   • Terms and conditions

   • Privacy policy compliance

4. Submission Process:

   • Submit via Partner Center

   • Microsoft validation team reviews (2-4 weeks typical)

   • Address feedback and resubmit if needed

   • Once approved, app published to AppSource marketplace

Ongoing Maintenance for AppSource Apps:

• Regular updates for new BC versions (every 6 months)

• Bug fixes and feature updates

• Respond to customer feedback/reviews

• Maintain compatibility with dependent apps

• Evaluate performance impact

• Assess user experience

• Verify documentation quality

• Test vendor support responsiveness

Best Practices for Maintaining Upgrade Compatibility

Ensure your customizations survive Business Central updates.

Extension Development Best Practices:

Use Events, Not Direct Modifications:

• Subscribe to published events for custom logic

• Don't modify base tables or code

• Request new events from Microsoft if needed

Follow Naming Conventions:

• Use unique prefixes for custom objects

• Number ranges: 50000-99999 for custom objects

• Descriptive, consistent naming

Respect Data Classification:

• Classify all custom fields appropriately

• Customer Content, Company Confidential, etc.

• Required for GDPR compliance

Version Control:

• Use Git or Azure DevOps

• Commit frequently with meaningful messages

• Branch strategy for different environments

• Tag releases

AL Extension Versioning and Dependency Management:

Extensions require careful version management to ensure smooth updates and compatibility:

App.json Version Fields:

{
  "id": "guid-here",
  "name": "Customer Loyalty Extension",
  "version": "1.2.3.0",
  "dependencies": [
    {
      "id": "guid-of-base-app",
      "name": "Base Application",
      "version": "19.0.0.0"
    }
  ],
  "application": "19.0.0.0",
  "platform": "19.0.0.0",
  "runtime": "9.0"
}

Semantic Versioning for Extensions:

• Major version (1.x.x.x): Breaking changes, incompatible API changes

• Minor version (x.1.x.x): New functionality, backward-compatible

• Patch version (x.x.1.x): Bug fixes, backward-compatible

• Build number (x.x.x.1): Build-specific identifier

Dependency Best Practices:

• Specify minimum required BC version in application field

• Use dependencies array for other extensions your extension relies on

• Test extension against new BC versions before customer updates

• Maintain compatibility with at least current and previous BC major release

Extension Lifecycle Management:

1. Development: Build and test in local Docker or sandbox

2. Sandbox Deployment: Deploy to customer sandbox for UAT

3. Production Deployment: Schedule deployment windows, notify users

4. Monitoring: Track extension performance and errors (see telemetry below)

5. Updates: Version increments, change logs, testing before deployment

Automated Testing:

• Write test codeunits for custom logic

• Automated regression testing

• Test after each Business Central update

• CI/CD pipeline integration

Application Insights Telemetry for Extensions:

Monitor extension performance and errors using Azure Application Insights:

Telemetry Setup:

1. Create Azure Application Insights resource in Azure Portal

2. Add Application Insights connection string to extension's app.json:

{
  "applicationInsightsConnectionString": "InstrumentationKey=xxx;IngestionEndpoint=https://..."
}

3. Business Central automatically sends telemetry signals to Application Insights

Telemetry Signals Tracked:

• Extension installation/uninstallation

• Extension upgrade events

• Runtime errors in extension code

• Performance metrics (page load times, report execution)

• Custom telemetry (use AL LogMessage() function)

Monitoring Dashboards:

• Application Insights provides pre-built dashboards

• Create custom queries using KQL (Kusto Query Language)

• Set up alerts for critical errors

• Track usage patterns and performance trends

Custom Telemetry Example:

Session.LogMessage('0000ABC', 'Customer loyalty points calculated', Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', 'LoyaltyCalculation');

Benefits:

• Proactive error detection before users report issues

• Performance optimization insights

• Usage analytics for feature prioritization

• Support troubleshooting with detailed error logs

Documentation:

• Document extension purpose and functionality

• Maintain changelog

• Document dependencies

• API documentation for integration points

Version Control and ALM (Application Lifecycle Management)

Professional development practices for extension management.

Source Control with Git:

Repository Structure:

Branching Strategy:

• main: Production-ready code

• develop: Integration branch for development

• feature/*: Individual feature development

• hotfix/*: Emergency production fixes

Development Workflow:

1. Development:

   • Create feature branch

   • Develop and test in sandbox

   • Commit regularly

   • Create pull request

2. Code Review:

   • Peer review of changes

   • Automated testing

   • Approval required

3. Integration:

   • Merge to develop branch

   • Deploy to integration environment

   • Integration testing

4. Release:

   • Merge to main branch

   • Create release tag

   • Deploy to production

   • Monitor and support

CI/CD Pipelines:

Azure DevOps Pipeline Example:

trigger:
  - main

pool:
  vmImage: 'windows-latest'

steps:
- task: ALOpsDockerCreate@1
  inputs:
    artifactversion: 'current'
    
- task: ALOpsDockerStart@1

- task: ALOpsAppCompiler@1
  inputs:
    nav_app_version: '1.0.0.0'
    
- task: ALOpsAppPublish@1

- task: ALOpsAppTest@1

- task

Benefits of ALM:

• Repeatable deployments

• Version tracking

• Rollback capability

• Quality assurance

• Team collaboration

• Audit trail

Deliverables: Customization & Integration Phase Outputs

Complete this phase with extensions and integrations in place:

1. Extension Development Checklist

Documentation of all customizations:

• Custom tables and table extensions

• Custom pages and page extensions

• Custom reports

• Integration endpoints

• AppSource extensions installed

2. Integration Architecture Diagrams

Visual documentation showing:

• System integration landscape

• Data flow directions

• Integration methods used

• Security and authentication

• Error handling approaches

3. API Documentation Standards

Complete API documentation:

• Endpoint definitions

• Request/response formats

• Authentication requirements

• Rate limits and throttling

• Error codes and handling

4. Customization Approval Workflow

Governance documentation:

• Change request process

• Development standards

• Testing requirements

• Approval authorities

• Deployment procedures

Frequently Asked Questions (FAQ)

What are Business Central extensions?

Business Central extensions are add-on packages that enhance or customize BC functionality without modifying the base application code:

Extension Types:

1. AppSource Extensions (Microsoft-Certified Marketplace Apps)

• What: Pre-built apps published on Microsoft AppSource marketplace

• Examples:

  • Shopify Connector: E-commerce integration

  • Avalara Tax: Automated sales tax calculation

  • Jet Reports: Advanced financial reporting

  • Continia Document Capture: Invoice OCR and automation

  • LS Retail: Point-of-sale for retail businesses

• Advantages:

  • ✅ Certified by Microsoft (quality assurance)

  • ✅ Supported by vendor (updates, bug fixes)

  • ✅ Upgrade-safe (tested with new BC releases)

  • ✅ Quick deployment (install from marketplace)

• Cost: Typically $20-$200/user/month subscription

2. Custom Per-Tenant Extensions (Organization-Specific)

• What: Custom-developed AL extensions for unique business needs

• Examples:

  • Custom commission calculation logic

  • Industry-specific workflows (pharmaceuticals, aerospace)

  • Specialized reporting requirements

  • Legacy system integration

• Advantages:

  • ✅ Tailored to exact requirements

  • ✅ Competitive differentiator

  • ✅ Full control over functionality

• Cost: $25K-$100K development + $5K-$15K annual maintenance

3. System Extensions (Microsoft-Provided)

• What: Extensions included with Business Central by Microsoft

• Examples:

  • Base Application

  • System Application

  • Core application functionality modules

• Cost: Included with BC licenses

How Extensions Work:

Key Benefit: Extensions allow customization while maintaining upgrade compatibility—when Microsoft releases BC updates, your extensions continue working (unlike legacy code modifications that broke during upgrades).

How do you develop Business Central extensions?

Business Central extension development follows a structured 8-step process:

Prerequisites:

• Visual Studio Code (free editor)

• AL Language extension for VS Code (free)

• Business Central Sandbox environment

• Azure DevOps or GitHub account (source control)

Step 1: Set Up Development Environment

1. Install Visual Studio Code

2. Install AL Language extension from VS Code marketplace

3. Install Docker Desktop (for local BC container development) OR connect to BC Sandbox

4. Download AL symbols from BC environment (enables IntelliSense)

Step 2: Create Extension Project

1. In VS Code: Press Ctrl+Shift+P → "AL: Go!"

2. Choose project type: "Your own app"

3. Enter app details:

   • Name: "Customer Loyalty Extension"

   • Publisher: Your company name

   • Version: 1.0.0.0

   • ID Range: 50000-50100 (assigned by Microsoft Partner Center)

4. Project structure created:

Step 3: Define Extension Manifest (app.json)

{
  "id": "12345678-1234-1234-1234-123456789012",
  "name": "Customer Loyalty Extension",
  "publisher": "Contoso Inc.",
  "version": "1.0.0.0",
  "brief": "Manage customer loyalty tiers and points",
  "description": "Extension to track customer loyalty program",
  "platform": "21.0.0.0",
  "application": "21.0.0.0",
  "runtime": "11.0",
  "dependencies": [
    {
      "id": "63ca2fa4-4f03-4f2b-a480-172fef340d3f",
      "name": "System Application",
      "publisher": "Microsoft",
      "version": "21.0.0.0"
    }
  ]
}

Key Fields:

• id: Unique GUID for your extension

• version: Semantic versioning (Major.Minor.Build.Revision)

• platform: Minimum BC platform version required

• dependencies: Other extensions required

Step 4: Develop Extension Objects

Example: Add "Customer Tier" field to Customer table

// CustomerTableExt.al
tableextension 50100 "Customer Loyalty Ext" extends Customer
{
    fields
    {
        field(50100; "Customer Tier"; Enum "Customer Tier")
        {
            Caption = 'Customer Tier';
            DataClassification = CustomerContent;
        }
        field(50101; "Loyalty Points"; Integer)
        {
            Caption = 'Loyalty Points';
            DataClassification = CustomerContent;
            MinValue = 0;
        }
    }
}

// CustomerTierEnum.al
enum 50100 "Customer Tier"
{
    Extensible = true;
    
    value(0; Bronze) { }
    value(1; Silver) { }
    value(2; Gold) { }
    value(3; Platinum) { }
}

// CustomerCardPageExt.al
pageextension 50100 "Customer Card Loyalty" extends "Customer Card"
{
    layout
    {
        addafter(Name)
        {
            field("Customer Tier"; Rec."Customer Tier")
            {
                ApplicationArea = All;
            }
            field("Loyalty Points"; Rec."Loyalty Points")
            {
                ApplicationArea = All;
            }
        }
    }
}

Step 5: Add Business Logic (Event Subscribers)

// LoyaltyManagement.Codeunit.al
codeunit 50100 "Loyalty Management"
{
    // Subscribe to event when sales invoice is posted
    [EventSubscriber(ObjectType::Codeunit, Codeunit::"Sales-Post", 'OnAfterSalesInvHeaderInsert', '', false, false)]
    local procedure AddLoyaltyPointsOnInvoice(var SalesInvHeader: Record "Sales Invoice Header")
    var
        Customer: Record Customer;
        PointsEarned: Integer;
    begin
        if Customer.Get(SalesInvHeader."Sell-to Customer No.") then begin
            // Award 1 point per $10 spent
            PointsEarned := Round(SalesInvHeader.Amount / 10, 1);
            Customer."Loyalty Points" += PointsEarned;
            Customer.Modify();
        end;
    end;
}

Step 6: Test Extension

1. Press F5 in VS Code → Extension deploys to Sandbox

2. Business Central opens in browser

3. Navigate to Customer Card → Verify new fields appear

4. Post sales invoice → Verify loyalty points update

5. Test edge cases (negative amounts, deleted customers)

Step 7: Package Extension

1. In VS Code: Ctrl+Shift+P → "AL: Package"

2. Extension compiled to .app file (e.g., CustomerLoyaltyApp_1.0.0.0.app)

3. Ready for deployment to production or AppSource submission

Step 8: Deploy to Production

Option A: Manual Upload (Small deployments)

1. Navigate to BC Admin Center → Environments → Production

2. Upload .app file

3. Extension installs and activates

Option B: CI/CD Pipeline (Recommended for teams)

1. Commit code to Azure DevOps or GitHub

2. Automated build pipeline compiles extension

3. Automated tests run

4. If tests pass, deploy to Sandbox → UAT → Production

Best Practices:

• ✅ Use semantic versioning (increment version for each release)

• ✅ Write unit tests using AL Test Framework

• ✅ Document code with XML comments

• ✅ Follow Microsoft AL coding standards

• ✅ Use source control (Git)

• ✅ Test upgrade scenarios (old version → new version)

Learning Resources:

• Microsoft Learn: "Develop for Dynamics 365 Business Central"

• AL Language documentation: docs.microsoft.com/dynamics365/business-central/dev-itpro/developer/

• YouTube: Business Central development tutorials

AppSource vs custom extensions—which should I choose?

Decision Framework to choose between AppSource apps and custom development:

Choose AppSource When:

✅ Requirement is Common Across Industries

• Example: Sales tax calculation, shipping integration, e-commerce, credit card processing

• Likelihood: High-quality AppSource app exists

✅ Speed to Deployment is Critical

• AppSource: Install in minutes/hours

• Custom: 4-12 weeks development + testing

✅ Budget is Limited for Upfront Costs

• AppSource: $20-$200/user/month (operational expense)

• Custom: $25K-$100K upfront (capital expense)

✅ Ongoing Support is Important

• AppSource: Vendor provides updates, bug fixes, BC compatibility

• Custom: You maintain or pay partner $5K-$15K annually

✅ Upgrade Safety is Priority

• AppSource: Vendor ensures compatibility with new BC releases

• Custom: You must test and update extensions

AppSource Examples with Cost:

• Shopify Connector (Microsoft): FREE

• Avalara Tax: ~$50/month base

• Continia Document Capture: ~$30-$50/user/month

• LS Retail: ~$100-$150/user/month

• Jet Reports: ~$40-$80/user/month

Choose Custom Extension When:

✅ Requirement is Unique to Your Business

• Example: Proprietary commission formula, specialized regulatory compliance, unique industry workflow

• No AppSource alternative exists

✅ Competitive Differentiator

• Custom functionality provides competitive advantage

• Not willing to share with competitors via AppSource

✅ Complex Integration with Legacy Systems

• Integration with proprietary on-premises systems

• Custom data transformations not supported by standard connectors

✅ Long-Term Cost Advantage

• High user count (100+ users) makes subscription expensive

• Example: $50/user/month × 100 users = $5,000/month = $60K/year

• Custom development: $50K one-time may break even in year 1

✅ AppSource App Exists BUT

• Too expensive for your user count

• Includes features you don't need (paying for bloat)

• Vendor has poor reviews or support reputation

• Doesn't meet specific compliance requirements

Custom Extension Examples with Cost:

• Simple extension (add fields, basic logic): $10K-$25K

• Moderate extension (workflow, calculations): $25K-$60K

• Complex extension (integration, advanced logic): $60K-$150K

• Annual maintenance: 20-30% of development cost

Hybrid Approach (Often Best):

Use AppSource for Common Needs + Custom Extensions for Unique Needs

Example:

• ✅ AppSource: Shopify connector (e-commerce)

• ✅ AppSource: Avalara (sales tax)

• ✅ Custom: Proprietary pricing engine

• ✅ Custom: Integration with legacy manufacturing system

Cost Comparison Example (100-user organization):

Decision Matrix:

Recommendation: Start with AppSource search. If 80%+ of requirement met, use AppSource. If <50% met or cost prohibitive, build custom.

How do you integrate Business Central with other systems?

Business Central offers multiple integration methods depending on requirements:

1. APIs (OData v4 / REST) - RECOMMENDED for Most Integrations

Best For: Real-time data sync, external app access, mobile apps

How It Works:

• Business Central exposes standard and custom APIs

• External systems call APIs via HTTP requests (GET, POST, PATCH, DELETE)

• JSON request/response format

• OAuth 2.0 authentication (Azure AD/Entra ID)

Standard APIs (Pre-Built by Microsoft):

• api/v2.0/customers - Customer management

• api/v2.0/items - Item/product catalog

• api/v2.0/salesOrders - Sales order processing

• api/v2.0/purchaseInvoices - AP invoice processing

• 50+ standard API endpoints available

Custom APIs (Build Your Own):

page 50100 "Customer Loyalty API"
{
    PageType = API;
    APIPublisher = 'contoso';
    APIGroup = 'loyalty';
    APIVersion = 'v1.0';
    EntityName = 'customerLoyalty';
    EntitySetName = 'customerLoyalties';
    SourceTable = Customer;
    
    layout
    {
        area(Content)
        {
            field(customerId; "No.") { }
            field(name; Name) { }
            field(loyaltyPoints; "Loyalty Points") { }
            field(tier; "Customer Tier") { }
        }
    }
}

API Call Example (JavaScript):

const response = await fetch('https://api.businesscentral.dynamics.com/v2.0/{tenant}/Production/api/v2.0/customers', {
  headers: {
    'Authorization': 'Bearer {access_token}',
    'Content-Type': 'application/json'
  }
});
const customers = await response.json();

Advantages:

• ✅ Real-time data access

• ✅ Industry-standard REST/JSON

• ✅ Secure (OAuth 2.0)

• ✅ Scalable

• ✅ External apps can integrate easily

Use Cases:

• E-commerce website ↔ BC inventory sync

• Mobile app accessing BC data

• External CRM ↔ BC customer sync

• Custom reporting dashboard

2. Power Platform (Power Automate, Power Apps, Power BI)

Best For: Low-code automation, workflows, custom apps, reporting

Power Automate (Workflow Automation):

• Pre-built BC connectors (200+ actions/triggers)

• Example flow: "When new customer created in BC → Create in Dynamics 365 Sales"

• No coding required (visual flow designer)

• Use Cases: Approval workflows, notifications, data sync, document routing

Power Apps (Custom Mobile/Web Apps):

• Build custom apps consuming BC data via connector

• Example: Field service app for technicians (read BC inventory, create sales orders)

• Use Cases: Mobile data entry, customer portals, specialized workflows

Power BI (Analytics & Reporting):

• Connect directly to BC OData feeds

• Build interactive dashboards and reports

• Embed in BC or standalone

• Use Cases: Executive dashboards, operational reporting, data analysis

Advantages:

• ✅ Low-code/no-code (business users can build)

• ✅ Pre-built connectors

• ✅ Included with BC licenses (or minimal add-on cost)

• ✅ Microsoft-supported

3. Azure Data Factory / Logic Apps (Enterprise ETL)

Best For: Large-scale data migrations, complex transformations, batch processing

How It Works:

• Cloud-based ETL (Extract, Transform, Load) platform

• Visual pipeline designer

• BC connector available

• Schedule automated data flows

Use Cases:

• Daily data sync: BC → Data Warehouse

• Complex multi-system integrations

• Large-volume data processing (millions of records)

Advantages:

• ✅ Enterprise-scale performance

• ✅ Complex transformation logic

• ✅ Scheduled/automated

• ✅ Monitoring and logging

Cost: ~$1-2 per execution hour

4. AL Extensions (Code-Based Integration)

Best For: Complex integration logic, legacy system connectivity, unique protocols

How It Works:

• Write AL code to call external APIs

• Use HttpClient to make REST/SOAP calls

• Scheduled via Job Queue or event-driven

Example (Call external API from BC):

procedure CallExternalAPI()
var
    Client: HttpClient;
    Response: HttpResponseMessage;
    Content: Text;
begin
    Client.Get('https://api.example.com/data', Response);
    Response.Content.ReadAs(Content);
    // Process response
end;

Use Cases:

• Integration with systems without standard APIs

• Complex business logic during integration

• Real-time validation against external system

5. File-Based Integration (Legacy Approach)

Best For: Systems without APIs, batch processing, legacy integrations

Methods:

• CSV/Excel Import/Export: Configuration Packages (user-friendly), XMLports (custom AL development for specialized formats)

• SFTP File Transfer: BC reads/writes files on SFTP server

• Email Attachments: Process invoices from email

Use Cases:

• Legacy system integration (no API available)

• Partner EDI (Electronic Data Interchange)

• Regulatory reporting (export to government format)

Limitations:

• ❌ Not real-time (batch only)

• ❌ Error-prone (file format issues)

• ❌ Requires monitoring

Integration Method Selection Guide:

Security Best Practices:

• ✅ Use OAuth 2.0 (never hardcode credentials)

• ✅ Implement rate limiting to prevent abuse

• ✅ Encrypt data in transit (HTTPS/TLS)

• ✅ Log integration activities (audit trail)

• ✅ Use service accounts with minimal permissions

• ✅ Implement retry logic with exponential backoff

• ✅ Monitor for failed integrations (alerts)

Conclusion: Extending Business Central Power

Customization, extensions, and integrations transform Business Central from a powerful standard platform into a solution precisely tailored to your unique business needs. The modern extensibility model ensures you can leverage these capabilities while maintaining upgrade safety and system stability.

Key Takeaways:

✓ Leverage Standard First: Explore configuration options before custom development

✓ Use Extensions, Not Modifications: AL extensions maintain upgrade compatibility

✓ Explore AppSource: Pre-built solutions often meet needs faster than custom development

✓ Integrate Thoughtfully: Choose integration methods appropriate to requirements

✓ Maintain Professionally: Source control, testing, and documentation are essential

✓ Plan for the Long Term: Build maintainable, scalable solutions

With your customized, integrated Business Central solution taking shape, you're ready for the next exciting phase: AI & Copilot Capabilities, where you'll explore how artificial intelligence enhances Business Central functionality.

Next in Series: Blog 6: AI & Copilot Capabilities in Business Central - Discover how AI and Copilot features transform daily operations with intelligent assistance.

Download Resources:

• Extension Development Checklist

• Integration Architecture Template

• API Documentation Template

• ALM Best Practices Guide

Questions or Comments? Share your customization and integration experiences in the comments below.

This is Part 5 of an 8-part series on Business Central Implementation. Subscribe to receive notifications when new articles are published.

Tags: #BusinessCentral #ALDevelopment #Extensions #Integration #API #PowerPlatform #CustomDevelopment