AL-Go for GitHub: A Practical CI/CD Framework for Business Central

Note: This blog is a personal notebook. I write it to record what I work on, for my own reference, not to publish it on social media or to promote myself. If a post is still useful to you, I am glad, but that is not why it exists.

This post was published on December 02, 2025. Software versions, product features, links, and tool availability may have changed since then. Always check official documentation for the latest information. Some screenshots show small details. Zoom in on the page to see them clearly.

AL-Go for GitHub is Microsoft’s official open-source DevOps framework for Business Central AL extensions. Its repository templates and prepared GitHub Actions automate build, test, release, and deployment. You write no pipeline code.


Problem

Before AL-Go, there was no standard way to automate CI/CD for AL extensions. A developer compiled the .app file locally, ran the tests by hand, copied the package to a server, and published it. Informal scripts and habit held it together.

Partners built their own pipelines in Azure DevOps or from BcContainerHelper scripts. As portfolios grew, these pipelines became expensive and fragile. Builds were inconsistent, releases were slow, and most teams ran no automatic tests.


Why this matters

A team goes from an empty repository to a working build and test pipeline in hours, not weeks, and each commit starts a compile and a test run.

Before AL-Go, each team washed the dishes by hand, in its own way. AL-Go is the dishwasher: load it, start it, and get the same result every time.

For a partner, the bigger gain is standardization: every project uses the same pipeline and settings, and all update together with each new AL-Go version.


Architecture

AL-Go runs completely outside Business Central. The logic lives in GitHub Actions workflows and in PowerShell code in the microsoft/AL-Go-Actions repository.

Repository structure:

A new project starts from one of two Microsoft templates:

  • Per-Tenant Extension (PTE) — customer-specific extensions for one tenant
  • AppSource App — extensions for Microsoft AppSource

Both contain prepared YAML workflows (CICD.yml, CreateRelease.yml, PublishToEnvironment.yml) that call the AL-Go Actions.

Build and test boundary:

A GitHub-hosted or self-hosted Windows runner uses BcContainerHelper to start a Business Central Docker container or connect to a cloud sandbox. It compiles the code and runs the test codeunits from a separate test app. No code reaches a production tenant.

Deployment boundary:

AL-Go uses service-to-service authentication (an Entra ID app registration with a secret or a certificate) and publishes the .app package through the Admin API. This write-back operation needs the right Business Central API permissions.

Configuration model:

JSON settings files (AL-Go-Settings.json and environment-level overrides) set the build targets, version numbers, and deployment destinations. Developers do not edit the YAML files, so updates stay safe.

Component Runs in Role
YAML workflows GitHub Actions Orchestration
AL-Go Actions (PS) GitHub runner Build, test, release logic
BcContainerHelper GitHub runner BC container/environment management
alc compiler GitHub runner AL compilation
Business Central Admin API BC SaaS / on-prem Extension deployment (write-back)
AL-Go-Settings.json Repository Pipeline configuration

Demo steps

  1. Prerequisites: A GitHub account, VS Code with the AL Language extension, and a Business Central sandbox (SaaS or Docker).

  2. Create the repository: Open github.com/microsoft/AL-Go-PTE or the AppSource template and click Use this template.

  3. Add your AL project: Put your extension folder, with app.json and the AL source, in the repository root. AL-Go finds every folder that contains an app.json file.

  4. Trigger CI: Push a commit or open a pull request. CICD.yml starts automatically. Watch the build in the Actions tab.

  5. Verify the artifact: After a successful build, download the .app package from the workflow artifacts and check the app version.

  6. Configure a deployment target (optional): Add the service principal credentials as secrets in a GitHub environment named after your Business Central target. Then start PublishToEnvironment to send the app to a sandbox.


What is intentionally simple

  • One AL project, one repository, one sandbox target
  • No branch protection, required reviewers, or approval gates
  • No test app, so AL-Go builds the code but runs no tests
  • No AppSource validation or submission

Risks/limits

BcContainerHelper deprecation: Microsoft has indicated that it will stop BcContainerHelper-based builds by October 2027, so the AL-Go build model will change. Follow the release notes, and avoid deep customizations of the current container mechanics.

Service principal management: The Entra ID app registration needs Business Central API permissions, and you must manage and rotate its secrets continuously.

Self-hosted runners for speed: GitHub-hosted runners suit small projects but are slow for large multi-app solutions. A self-hosted Windows runner with a cached Business Central image is faster, but adds infrastructure work.

No built-in approval workflow: Without environment protection rules and required reviewers, nothing stops an automatic deployment to production.

Code quality is out of scope: AL-Go checks that the code compiles and the tests pass. Architecture, coding guidelines, and performance need other tools or a manual review.


Next iteration

  • Add a test app, so that CI runs real tests
  • Require approvers before a production deployment
  • Add AppSourceCop and PerTenantExtensionCop as a CI quality gate
  • Prepare for the build model after BcContainerHelper

Closing note

AL-Go solves a real problem directly. The Business Central product team maintains the pipeline, so your team needs no deep GitHub Actions knowledge. Your investment is the initial setup and the discipline to keep the test app in step with the main extension.

← Back to AL-Go