Study guide

1.1 Business Central Architecture & Extensions Model

Microsoft Dynamics 365 Business Central Developer MB-820

Track your progress as you read

Finished sections get a check mark.

1 Chapter 1: Business Central Architecture & Platform Foundation

1.1 Business Central Architecture & Extensions Model 1.2 Customization Lifecycle: Cloud (SaaS) vs. On-Premises 1.3 Base Application, System Application & AppSource

2 Chapter 2: Development Environment & Configuration

2.1: Development Environment Setup: VS Code, AL: Go! Projects & Sandboxes 2.2: AL Configuration Files: app.json & launch.json Parameters 2.3: Multi-Root Workspaces & Project Dependencies

3 Chapter 3: Extension Lifecycle: Debugging, Deployment, Multilanguage & Maintenance

3.1 Debugging & Snapshot Debugging in Visual Studio Code 3.2 Extension Deployment & Schema Synchronization Modes 3.3 Multilanguage Development with XLIFF & Translation Files 3.4 Extension Maintenance, Deprecation & Breaking Changes

4 Chapter 4: Tables, Table Extensions & Data Modeling

4.1: Building Tables, Fields, Keys & Data Types 4.2: Table Extensions & Table Modifications 4.3: FlowFields, FlowFilters & Table Relations 4.4: Enums, Enum Extensions & Extensible Types

5 Chapter 5: Pages, Page Extensions & Role Centers

5.1: Page Types, Anatomy & Control Structure 5.2: Building Card, List & Document Pages 5.3: Page Extensions & Page Customizations 5.4: Role Centers, Headlines & Cue Data Modeling

6 Chapter 6: Reports & Document Generation

6.1 Report Architecture, DataItems & Dataset Design 6.2 Report Layouts: RDLC, Word, Excel & Multilanguage 6.3 Document Reports & Request Page Programming 6.4 Processing-Only Reports & Report Substitutions

7 Chapter 7: XMLports & Data Exchange

7.1 XMLport Architecture, Formats & Properties 7.2 XMLport Node Hierarchy, Triggers & Stream Manipulation

8 Chapter 8: Codeunits, Events, Triggers & Interfaces

8.1 Codeunit Types, Execution & SingleInstance Codeunits 8.2 Events, Publishers, Subscribers & Event Isolation 8.3 Interfaces, Polymorphism & Dynamic Codeunit Invocation 8.4 Installation & Upgrade Codeunits, Data Transfer & Archive

9 Chapter 9: Entitlements, Permissions & Queries

9.1 Permission Sets & Permission Set Extensions 9.2 Inherent Permissions, Inherent Entitlements & Security Scoping 9.3 Query Objects: Joins, Aggregation & Query as Report Data Source

10 Chapter 10: UI Customization, User Assistance & Onboarding

10.1 Profile Objects & Custom Page Views in AL 10.2 User Assistance: ToolTips, Teaching Tips & In-App Tours 10.3 Assisted Setup, Guided Experience & Onboarding Checklists

11 Chapter 11: Business Central Design Patterns & Data Process Model

11.1 Functional Table Types: Master Data, Supplemental & Setup Patterns 11.2 Document Standards: Header, Line, History & Journal Architectures 11.3 Data Process Model & Posting Routine Architecture

12 Chapter 12: AL Language Fundamentals, Data Types & Variables

12.1 AL Syntax, Variable Scope, Primitive & Complex Data Types 12.2 Expressions, Control Flow Statements & Built-in Functions 12.3 Access Modifiers (Public, Internal, Local) & Code Scoping

13 Chapter 13: Data Manipulation, Streams & Error Handling

13.1 Record Operations: Get, FindSet, ModifyAll & Filter Functions 13.2 Streams, File Management & TempBlob 13.3 Error Handling: ErrorInfo, TryFunctions & Collectible Errors

14 Chapter 14: Testing, Test Toolkit & Automation

14.1 Testing Architecture & the Test Toolkit 14.2 Authoring Test Codeunits & UI Handler Functions

15 Chapter 15: Telemetry, Performance Optimization & Analyzers

15.1 Telemetry Configuration & Azure Application Insights 15.2 Custom Telemetry Signals with Session.LogMessage & KQL 15.3 Performance Profiler, SetLoadFields & Query Optimization 15.4 AL Analyzers: CodeCop, AppSourceCop, UICop & PTECop

16 Chapter 16: REST Web Services & JSON in AL

16.1 HttpClient, HttpRequestMessage & REST API Consumption 16.2 JSON Processing: JsonObject, JsonArray, JsonValue & JsonToken

17 Chapter 17: API Pages, OData, Read Scale-Out & OAuth

17.1 API Pages (PageType=API), OData Web Services & REST Endpoints 17.2 Bound and Unbound OData Actions with [ServiceEnabled] 17.3 Read Scale-Out Architecture & DataAccessIntent Configuration 17.4 Microsoft Entra ID App Registrations & OAuth 2.0 Integration

1.1 Business Central Architecture & Extensions Model

Key Takeaways Explain This Topic AI

Dynamics 365 Business Central operates on a multi-tier cloud-native architecture comprising the Web Client (browser/mobile/Teams), Business Central Server (Navision Server Tier / NST runtime host), and the SQL Database (Azure SQL DB / SQL Server).

The modern AL extension model enforces absolute immutability of the base application codebase; all modifications are additive and isolated within extension packages (.app files).

At runtime, the NST resolves table extensions by generating companion tables in SQL Server, executing automatic primary key joins without altering underlying base table schemas.

Customizations are decoupled from core business transactions through event-driven architecture, using Integration Events, Business Events, and Event Subscribers.

Per-Tenant Extensions (PTE) are deployed to individual customer tenants for bespoke business requirements, whereas AppSource Apps are globally distributed, multitenant ISV solutions subject to strict certification gates.

Last updated: August 2026

1.1 Architecture, Components & Extensions Approach

Microsoft Dynamics 365 Business Central is an enterprise resource planning (ERP) platform built on a modern, decoupled three-tier architecture. For developers preparing for the MB-820 certification, mastering the physical and logical layers of the platform—and understanding how the AL runtime executes code without altering core binaries—is the foundational prerequisite for all development tasks.

1. The Three-Tier Architectural Topology

The Business Central architecture separates presentation, business logic execution, and data persistence into distinct tiers. This separation allows the platform to scale horizontally in Microsoft Azure while providing a consistent developer and user experience across cloud (SaaS) and on-premises deployments. +-----------------------------------------------------------------------+

  • | CLIENT TIER |
  • | - Modern Web Client (HTML5 / TypeScript / React) |
  • | - Mobile & Tablet Apps (iOS / Android) |
  • | - Microsoft 365 Integrations (Teams Tabs / Outlook Web Add-ins) |
  • | - External Web Service Consumers (REST / OData v4 / SOAP / APIs) |
  • +-----------------------------------------------------------------------+
  • │ (HTTPS / WebSockets / WCF / TLS 1.3)
  • ▼
  • +-----------------------------------------------------------------------+
  • | BUSINESS CENTRAL SERVER (NST) TIER |
  • | - Navision Server Tier (.NET Core Runtime Service Host) |
  • | - AL Metadata Compiler & Virtual Execution Engine |
  • | - Data Access Layer (DAL) & SQL Query Generator |
  • | - In-Memory Cache (Global Object Cache, Record & Query Cache) |
  • | - Session Manager, Background Task Scheduler & Job Queue Engine |
  • | - API & OData Web Service Endpoints |
  • +-----------------------------------------------------------------------+
  • │ (Encrypted TDS / SQL Connection Pool)
  • ▼
  • +-----------------------------------------------------------------------+
  • | DATA TIER |
  • | - Azure SQL Database (Cloud SaaS) / SQL Server (On-Premises) |
  • | - Base Application Tables & Data Dictionary Metadata |
  • | - Extension Companion Tables ([AppID$Table$ExtID]) |
  • | - Document Storage & Azure Blob Storage for Attachments |
  • | - Tenant-Isolated Schemas (Multi-Tenant Shared DB / Dedicated DB) |
  • +-----------------------------------------------------------------------+
  • Tier 1: The Client Tier (Presentation)

The presentation layer consists entirely of web-based and API-driven interfaces. Unlike legacy Dynamics NAV clients (the Windows Classic and RoleTailored clients), modern Business Central clients execute no local business logic:

Web Client: A responsive HTML5, CSS, and TypeScript application rendered by the Web Server component. It communicates with the server tier over HTTPS and WebSockets for real-time UI updates.

Mobile & Tablet Apps: Native wrapper shells for iOS and Android that render the responsive Web Client layout customized for touch gestures and mobile form factors.

Microsoft 365 Integrations: Deeply embedded clients within Microsoft Teams (context cards and tab views) and Microsoft Outlook (email document lookup add-in).

External API Clients: Third-party applications, Power Platform connectors, and integration pipelines consuming standard API pages ( PageType = API ) and OData v4 endpoints.

Tier 2: Business Central Server (Navision Server Tier - NST)

The middle tier is a high-performance, multi-tenant .NET Core application service known historically and internally as the Navision Server Tier (NST) . The NST acts as the orchestration brain of the platform:

AL Execution Engine: Loads compiled AL packages ( .app ), caches object definitions, and executes AL business logic in an optimized virtual runtime.

Data Access Layer (DAL): Translates high-level AL record operations ( Rec.FindSet() , Rec.CalcFields() , Rec.ModifyAll() ) into parameterized, optimized Transact-SQL (T-SQL) statements.

Caching Layer: Maintains in-memory caches of table schemas, user permissions, compiled AL bytecode, and record data (global cache and session-level cache) to minimize round-trips to the database tier.

Session & Job Queue Engine: Manages active user sessions, web service workers, child background sessions ( TaskScheduler.CreateTask() ), and automated scheduled jobs.

Tier 3: The Data Tier (Persistence)

The data layer handles physical data storage, transactional integrity (ACID compliance), and schema management:

Cloud (SaaS): Hosted on elastic Azure SQL Database instances managed entirely by Microsoft, featuring automated backups, read scale-out replicas, and threat detection.

On-Premises: Hosted on Microsoft SQL Server or Azure SQL Managed Instance, allowing direct database access and custom DBA maintenance plans.

Tenant Separation: In a multi-tenant cloud environment, multiple tenant databases can connect to a shared NST cluster, or tenants share a single database containing isolated tenant schema partitions.

Loading diagram... Business Central 3-Tier Architecture & Extension Layering Model

2. The Modern Extensions Model vs. Legacy C/SIDE

In legacy versions of Dynamics NAV (prior to Business Central 2018 / AL), customizations were developed using C/SIDE (Client/Server Integrated Development Environment) and the C/AL language. In C/SIDE, developers directly modified the base Microsoft source code. If a partner needed to add a field to the Customer table or modify a posting routine in Codeunit 80 ( Sales-Post ), they changed the core object directly.

The Upgrade Debt Problem of C/SIDE

Direct code modification created severe technical friction:

Monolithic Entanglement: Upgrades required manual line-by-line code merges (using text comparison tools) across hundreds of modified objects.

High Upgrade Costs: Upgrading to a new release took months of billable effort, leaving thousands of customers stranded on obsolete NAV versions.

Zero SaaS Feasibility: A multi-tenant public cloud cannot allow tenants to overwrite shared base application binaries.

The Additive Modern AL Model

Modern Business Central development uses the AL (Application Language) extension model. In this paradigm, Microsoft's Base Application and System Application are completely immutable packages ( .app files). Developers can never modify, overwrite, or delete lines of Microsoft source code. Customizations are strictly additive and packaged into independent, modular extensions. Legacy C/SIDE Approach (Destructive Overwrite):

[ Base Application Source Code ] ──> (Developer edits line 42) ──> [ Broken Upgrade Path ]

Modern AL Extension Approach (Additive & Layered):

  • [ Base Application (.app) ] ── (Immutable Core Engine) ──
  • ▲
  • │ Depends on
  • [ AppSource ISV App (.app) ] ── (Extends Tables, Adds Pages, Hooks Events)
  • ▲
  • │ Depends on
  • [ Per-Tenant Extension (.app) ] ── (Adds Customer-Specific Fields & Logic)
  • Extension Object Types in AL

AL introduces specialized extension objects that augment existing base objects without touching their definitions:

AL Object Type Purpose Underlying Behavior

tableextension Adds fields, keys, field groups, and triggers to base tables Creates a companion table in SQL; NST joins it automatically on primary key.

pageextension Adds UI controls, actions, views, and layout modifications to base pages Modifies page metadata at runtime; rendered seamlessly by the Web Client.

reportextension Adds dataset columns, dataitems, request page controls, and RDLC/Excel/Word layouts to base reports Injects additional data elements into the report dataset pipeline.

enumextension Adds custom enum values to extensible base enums Appends new selectable options to system and business dropdown lists.

permissionsetextension Adds object permissions to existing base permission sets Extends role security boundaries without duplicating permission records.

3. Database Layer Mechanics: Companion Tables

When a developer creates a tableextension in AL to add custom fields to an existing base table (such as Customer or Item ), Business Central does not execute ALTER TABLE [Customer] ADD [CustomField]... on the physical database. Modifying base tables directly would lock shared schemas and break version rollbacks.

Instead, the NST creates a Companion Table in the SQL database:

Naming Convention: [Company$BaseTableName$AppGUID] (e.g., CRONUS USA, Inc.$Customer$4378856a-1b4e-4fc1-a832-6a365287f3b5 ).

Primary Key Matching: The companion table contains the identical primary key field(s) of the base table along with the newly declared custom fields.

Transparent Joining: When AL code requests records via Rec.Get() or Rec.FindSet() , the NST Data Access Layer automatically performs an internal SQL LEFT OUTER JOIN between the base table and all installed companion tables matching the active tenant and extension set.

Performance Optimization: If the developer uses modern AL partial record capabilities ( Rec.SetLoadFields('CustomField') ), the NST avoids joining unused companion tables, minimizing SQL I/O overhead.

4. Event-Driven Architecture: Decoupling Logic

Because developers cannot insert custom lines of code into base business routines (such as ledger posting routines Sales-Post or Gen. Jnl.-Post Line ), Business Central relies on an Event-Driven Architecture to execute custom code.

Event Publishers vs. Event Subscribers

Event Publishers: Declared in base codeunits and tables using [IntegrationEvent] or [BusinessEvent] attributes. Microsoft embeds thousands of event hooks before, during, and after critical transactions.

Event Subscribers: Declared in custom extension codeunits using the [EventSubscriber] attribute. When the published event fires, the runtime executes all subscribed listener procedures. // Base Microsoft Codeunit 80 ("Sales-Post") publishes an integration event:

[IntegrationEvent(false, false)]

local procedure OnBeforePostSalesDoc(var SalesHeader: Record "Sales Header"; PreviewMode: Boolean; CommitIsSuppressed: Boolean; var IsHandled: Boolean)

  • begin
  • end;

// Custom Per-Tenant Extension Codeunit subscribes to the event:

  • [EventSubscriber(ObjectType::Codeunit, Codeunit::"Sales-Post", 'OnBeforePostSalesDoc', '', false, false)]
  • local procedure CheckCustomCreditHold(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean)
  • var
  • Customer: Record Customer;

CustomCreditHoldErr: Label 'Customer %1 is placed on mandatory executive credit hold.', Comment = '%1 = Customer No.';

  • begin
  • if SalesHeader."Document Type" = SalesHeader."Document Type"::Order then begin
  • Customer.Get(SalesHeader."Sell-to Customer No.");
  • if Customer."Custom Credit Blocked" then
  • Error(CustomCreditHoldErr, Customer."No.");
  • end;
  • end;

Exam Watchout — The IsHandled Pattern: Many Microsoft integration events pass a var IsHandled: Boolean parameter. If your subscriber sets IsHandled := true; , it signals to the base calling routine that custom logic has fulfilled the operation, causing the base routine to bypass its default implementation. Use this pattern cautiously to avoid breaking standard accounting integrity.

5. Per-Tenant Extensions (PTE) vs. AppSource Apps

In modern Business Central development, all custom AL code is authored as an extension package, but extensions are bifurcated into two distinct operational categories:

Architectural Attribute Per-Tenant Extension (PTE) AppSource Application (ISV)

Target Audience A single customer organization / tenant. Global commercial market across thousands of tenants.

Customization Scope Highly tailored client business logic and bespoke integrations. Standardized, reusable vertical industry or horizontal functional solutions.

Compilation Target Configurable via app.json : "target": "Cloud" or "OnPrem" . Mandatory: "target": "Cloud" . Must be 100% cloud-compliant.

Code Analyzers Enforces CodeCop and PTECop . Mandatory: AppSourceCop , CodeCop , UICop , and PerTenantExtensionCop .

Identifier Prefix/Suffix Recommended for clarity; not enforced by Partner Center registry. Mandatory: 3-to-4 character prefix or suffix registered in Microsoft Partner Center.

Distribution Channel Uploaded directly via BC Web Client ( Extension Management ) or Admin Center. Distributed and monetized exclusively through Microsoft AppSource Marketplace.

Breaking Change Policy Managed internally by the partner; can synchronize using clean modes in sandboxes. Strict backward-compatibility rules enforced by AppSourceCop (zero breaking changes).

Upgrade Validation Validated automatically by Microsoft against upcoming preview sandboxes. Automated validation pipeline across all global environments; partner must fix breaks before GA.

Extension Dependencies and Layering Rules

Extensions can establish explicit dependencies on other extensions through the dependencies array in app.json :

An extension can depend on the System Application , the Base Application , and any number of AppSource Apps or Library PTEs .

When Extension B depends on Extension A, Extension B has access to all public and internal (if granted via internalsVisibleTo ) objects, tables, fields, and procedures declared in Extension A.

Circular dependencies are strictly illegal: Extension A cannot depend on Extension B if Extension B directly or indirectly depends on Extension A.

If Extension A is uninstalled, any dependent Extension B must either be uninstalled first or cascaded during the uninstallation operation.