If you’re starting your journey into Microsoft Dynamics 365 Business Central development, AL Language is the gateway. AL (Application Language) is Microsoft’s proprietary programming language designed specifically for extending Business Central — and it’s what every BC developer must master.

This complete beginner’s guide walks you through everything you need to start building your first Business Central extension in 2026: what AL is, how to set up your development environment, the core AL object types, hands-on code examples, and how to deploy your first extension to a real BC tenant.

By the end of this guide, you’ll have a working “Hello World” extension running in your own Business Central sandbox — and you’ll understand the foundations to keep building.

What is AL Language?

AL (Application Language) is Microsoft’s domain-specific programming language for developing extensions and customizations on top of Microsoft Dynamics 365 Business Central. It replaced the older C/AL language when Microsoft transitioned from NAV (Navision) to modern cloud-first Business Central in 2018.

AL is purpose-built for business application development. Unlike general-purpose languages like JavaScript or Python, AL has native concepts for:

• Database tables (with built-in field types like Code, Decimal, Boolean)
• User interface pages (lists, cards, role centers)
• Business logic (codeunits, triggers, events)
• Reports (both classic and Word/Excel layouts)
• Web services (APIs exposed automatically from your objects)
• Permissions and security (built-in role-based access)

If you’ve worked with SQL + a business framework like Salesforce Apex or SAP ABAP, AL will feel familiar — it’s a strongly-typed, object-oriented language with the ERP system baked in at the language level.

Why Learn AL in 2026?

The Microsoft Dynamics 365 Business Central ecosystem is growing rapidly, and AL developers are in high demand worldwide:

✅ High earning potential — AL developers in India earn ₹6-25 lakh/year depending on experience. Globally, $70,000-$150,000/year is typical.

✅ Cloud-first future — Business Central is Microsoft’s #1 growth ERP. Every new BC tenant needs AL extensions for customizations.

✅ Lower entry barrier than enterprise platforms — Compared to SAP ABAP or Oracle PeopleCode, AL has a friendlier learning curve and free development tools.

✅ AppSource opportunity — Build extensions, publish to Microsoft AppSource, earn recurring revenue from customers worldwide.

✅ Career flexibility — Work as an in-house BC developer, partner consultant, or independent contractor. The MB-820 Developer Associate certification credentials your skills.

✅ Adjacent to Copilot AI — As Microsoft embeds Copilot deeper into BC, AL developers who understand AI integration patterns are uniquely valuable.

Prerequisites Before You Start

To follow this guide, you should have:

• A Windows, Mac, or Linux computer with internet access
• Basic programming familiarity (you’ve written code in any language before — variables, loops, functions)
• A free Microsoft account (any @outlook.com, @hotmail.com, or even @gmail.com works)
• Optional but recommended: Basic SQL knowledge (understanding tables, rows, columns)

You do NOT need:

• ❌ A paid Business Central license (we’ll use a free 30-day trial sandbox)
• ❌ Prior Microsoft Dynamics experience
• ❌ Advanced math or computer science background

Setting Up Your AL Development Environment

The AL development setup is free and takes about 20-30 minutes. Here’s what you need to install:

Step 1: Install Visual Studio Code

VS Code is Microsoft’s free, lightweight code editor — and it’s the official IDE for AL development.

1. Visit code.visualstudio.com
2. Download the version for your operating system
3. Install with default settings

Step 2: Install the AL Language Extension

This is the magic that turns VS Code into a Business Central development powerhouse.

1. Open VS Code
2. Click the Extensions icon in the left sidebar (or press Ctrl+Shift+X)
3. Search for: “AL Language”
4. Look for the extension by Microsoft (verified blue checkmark)
5. Click Install

After installation, the AL Language extension provides:

• AL syntax highlighting
• IntelliSense (auto-completion as you type)
• Built-in compiler and error checking
• Direct deployment to Business Central sandboxes
• Object Designer integration
• Symbol downloader (gets all standard BC objects for reference)

Step 3: Create a Free Business Central Sandbox

You need a BC environment to deploy your AL extensions to. Microsoft provides free 30-day trial sandboxes.

1. Visit trials.dynamics.com
2. Select “Dynamics 365 Business Central”
3. Sign in with your Microsoft account
4. Select region (choose your country for accurate pricing/tax demo data)
5. Wait 5-10 minutes for the sandbox to provision
6. You’ll receive an email with your BC URL (typically https://businesscentral.dynamics.com/[your-tenant]/Sandbox)

Step 4: Create Your First AL Project

Now we’ll create the project folder structure:

1. Open VS Code
2. Press Ctrl+Shift+P to open the Command Palette
3. Type: “AL: Go!”
4. Select “AL: Go!” from the dropdown
5. Choose a folder location for your project (create a new empty folder)
6. Select “Microsoft cloud sandbox” when prompted
7. VS Code creates the project structure with default files

HelloWorld/
├── .vscode/
│ └── launch.json ← Connection settings to your BC sandbox
├── app.json ← App manifest (id, name, publisher, version)
├── HelloWorld.al ← Your first AL object (a page extension)
└── .gitignore

Step 5: Connect to Your Sandbox

Open launch.json and update the tenant, environmentName, and startupObjectId fields based on your sandbox details (these come from your BC trial URL).

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Sandbox: BC Trial",
            "request": "launch",
            "type": "al",
            "environmentType": "Sandbox",
            "environmentName": "Sandbox",
            "tenant": "common",
            "startupObjectId": 22,
            "startupObjectType": "Page",
            "schemaUpdateMode": "ForceSync",
            "breakOnError": true
        }
    ]
}

Understanding AL Object Types

Before writing code, understand the core building blocks. AL has several object types, but as a beginner you’ll primarily work with these:

1. Tables — Store Your Data

Tables in AL are like SQL tables but with built-in field validation, triggers, and UI integration.

Example use case: You want to track “Service Requests” from customers — a custom table that doesn’t exist in standard BC.

2. Pages — Display the UI

Pages are how users interact with table data. There are several page types:

• List pages — Show records in a table format (like a spreadsheet)
• Card pages — Show one record at a time (like a contact card)
• Role centers — Custom dashboards for specific user roles
• API pages — Expose your tables as REST APIs automatically

3. Codeunits — Business Logic

Codeunits contain procedures (functions/methods) for your business logic. Reusable, testable, and can be triggered by events.

Example use case: A codeunit that calculates a customer discount based on order history.

4. Reports — Printed/Exported Output

Reports generate printable or exportable documents (invoices, customer statements, inventory reports).

5. Extensions to Existing Objects

You’ll often need to add fields, actions, or behaviors to standard BC objects (like the Customer table or Sales Order page). AL provides table extensions and page extensions for this.

Code Example 1: Your First Custom Table

Let’s create a simple “Service Request” table. Replace the contents of HelloWorld.al with:

table 50100 "Service Request"
{
    Caption = 'Service Request';
    DataClassification = CustomerContent;

    fields
    {
        field(1; "Request No."; Code[20])
        {
            Caption = 'Request No.';
            DataClassification = CustomerContent;
        }
        field(2; "Customer No."; Code[20])
        {
            Caption = 'Customer No.';
            DataClassification = CustomerContent;
            TableRelation = Customer."No.";
        }
        field(3; "Description"; Text[100])
        {
            Caption = 'Description';
            DataClassification = CustomerContent;
        }
        field(4; "Request Date"; Date)
        {
            Caption = 'Request Date';
            DataClassification = CustomerContent;
        }
        field(5; "Status"; Enum "Service Request Status")
        {
            Caption = 'Status';
            DataClassification = CustomerContent;
        }
        field(6; "Priority"; Option)
        {
            Caption = 'Priority';
            OptionMembers = Low,Medium,High,Critical;
            DataClassification = CustomerContent;
        }
    }

    keys
    {
        key(PK; "Request No.")
        {
            Clustered = true;
        }
    }
}

enum 50100 "Service Request Status"
{
    Extensible = true;

    value(0; Open) { Caption = 'Open'; }
    value(1; "In Progress") { Caption = 'In Progress'; }
    value(2; Resolved) { Caption = 'Resolved'; }
    value(3; Closed) { Caption = 'Closed'; }
}

Key concepts demonstrated:

• table 50100 â€” Object ID in the per-tenant extension range (50000-99999)
• Caption â€” User-visible label
• DataClassification â€” Required for GDPR compliance
• Code[20] â€” Code field type (max 20 chars, alphanumeric)
• TableRelation â€” Links to Customer table for referential integrity
• Enum â€” Type-safe enumeration (modern replacement for Option)
• keys â€” Primary key definition

Code Example 2: Display Data with a List Page

Now let’s create a page to display service requests. Add this AL code to a new file ServiceRequestList.al:

page 50100 "Service Request List"
{
    Caption = 'Service Requests';
    PageType = List;
    SourceTable = "Service Request";
    UsageCategory = Lists;
    ApplicationArea = All;
    CardPageId = "Service Request Card";

    layout
    {
        area(Content)
        {
            repeater(Group)
            {
                field("Request No."; Rec."Request No.")
                {
                    ApplicationArea = All;
                }
                field("Customer No."; Rec."Customer No.")
                {
                    ApplicationArea = All;
                }
                field("Description"; Rec."Description")
                {
                    ApplicationArea = All;
                }
                field("Request Date"; Rec."Request Date")
                {
                    ApplicationArea = All;
                }
                field("Status"; Rec."Status")
                {
                    ApplicationArea = All;
                    StyleExpr = StatusStyle;
                }
                field("Priority"; Rec."Priority")
                {
                    ApplicationArea = All;
                }
            }
        }
    }

    actions
    {
        area(Processing)
        {
            action(MarkResolved)
            {
                Caption = 'Mark as Resolved';
                ApplicationArea = All;
                Image = Approve;

                trigger OnAction()
                begin
                    Rec.Status := Rec.Status::Resolved;
                    Rec.Modify(true);
                end;
            }
        }
    }

    var
        StatusStyle: Text;

    trigger OnAfterGetRecord()
    begin
        case Rec.Status of
            Rec.Status::Open: StatusStyle := 'Attention';
            Rec.Status::"In Progress": StatusStyle := 'Ambiguous';
            Rec.Status::Resolved: StatusStyle := 'Favorable';
            Rec.Status::Closed: StatusStyle := 'Subordinate';
        end;
    end;
}

Key concepts demonstrated:

• PageType = List â€” Page renders as a list/grid
• SourceTable â€” Connects page to the underlying table
• UsageCategory = Lists â€” Makes page searchable in BC Tell Me
• repeater â€” Renders the table as repeating rows
• StyleExpr â€” Color-code rows based on status
• actions â€” Add buttons to the page ribbon
• trigger OnAction â€” Code that runs when button clicked
• trigger OnAfterGetRecord â€” Runs after each record loaded

Code Example 3: Add Business Logic with a Codeunit

Codeunits contain reusable business logic. Let’s create one to auto-assign request numbers:

codeunit 50100 "Service Request Mgt."
{
    procedure AssignRequestNumber(var ServiceRequest: Record "Service Request")
    var
        LastRequest: Record "Service Request";
        NextNo: Integer;
    begin
        if ServiceRequest."Request No." <> '' then
            exit;

        LastRequest.Reset();
        if LastRequest.FindLast() then
            NextNo := GetNumericPart(LastRequest."Request No.") + 1
        else
            NextNo := 1;

        ServiceRequest."Request No." := 'SR-' + Format(NextNo, 6, '<Integer,6><Filler Character,0>');
    end;

    local procedure GetNumericPart(RequestNo: Code[20]): Integer
    var
        NumericString: Text;
        i: Integer;
    begin
        for i := 1 to StrLen(RequestNo) do
            if RequestNo[i] in ['0'..'9'] then
                NumericString += RequestNo[i];

        if NumericString = '' then
            exit(0);

        exit(Evaluate(NumericString));
    end;

    [EventSubscriber(ObjectType::Table, Database::"Service Request", 'OnBeforeInsertEvent', '', false, false)]
    local procedure OnBeforeInsertServiceRequest(var Rec: Record "Service Request")
    begin
        AssignRequestNumber(Rec);

        if Rec."Request Date" = 0D then
            Rec."Request Date" := Today();
    end;
}

Key concepts demonstrated:

• procedure â€” Public method callable from other objects
• local procedure â€” Helper method only callable within this codeunit
• var keyword — Pass parameter by reference
• EventSubscriber â€” Subscribe to BC’s event system (modern AL pattern)
• OnBeforeInsertEvent â€” Runs automatically when a new Service Request is inserted

AL Language Essentials

These language fundamentals appear in nearly every AL project:

Variables and Data Types

var
    CustomerNo: Code[20];
    Amount: Decimal;
    IsActive: Boolean;
    OrderDate: Date;
    OrderTime: Time;
    Description: Text[100];
    Counter: Integer;

Conditionals

if Amount > 1000 then
    ApplyDiscount()
else
    StandardPricing();

case Status of
    Status::Open: ProcessOpen();
    Status::Closed: ProcessClosed();
    else
        DefaultAction();
end;

Loops

// For loop
for i := 1 to 10 do
    Message('Iteration %1', i);

// Foreach record loop
if Customer.FindSet() then
    repeat
        ProcessCustomer(Customer);
    until Customer.Next() = 0;

// While loop
while Counter < 100 do
    Counter += 1;

Working with Records

// Find single record
Customer.Get('10000');

// Filter and iterate
Customer.SetRange("Country/Region Code", 'IN');
Customer.SetFilter("Sales (LCY)", '>%1', 100000);
if Customer.FindSet() then
    repeat
        // Do something with each filtered customer
    until Customer.Next() = 0;

// Insert new record
NewCustomer.Init();
NewCustomer."No." := '50000';
NewCustomer.Name := 'BizCentralOrbit Demo';
NewCustomer.Insert(true);