GitHub and AL: The DevOps Shift Business Central Teams Need

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 November 18, 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.

In 2018, Microsoft replaced C/AL with AL and the extension model. That made modern source control possible for the first time in the NAV and Business Central line. GitHub is now the primary target for Microsoft’s Business Central DevOps tools.


Problem

C/AL customizations lived in the ERP database, and developers changed objects directly in C/SIDE. To find who changed what, you exported object files and compared them by hand. When two developers changed the same object, one lost the work.

AL turned extensions into files that compile to .app packages, separate from the core application. That solves only the structure problem. Without Git and a real branch workflow, a team still has unrecorded changes and fragile manual releases:

  • An urgent hotfix. Without branches, you change the live extension and hope.
  • Parallel feature work. Without feature branches, work is overwritten or a developer waits.
  • A version upgrade. Without CI tests against preview containers, you find breaking changes on release day.

Why this matters

The extension model made it cheaper to follow the two major releases each year, but only for teams that can deploy reliably. Without version control and CI, every release is a risky manual operation.

For AppSource partners, GitHub is almost mandatory: AL-Go and AppSourceCop run on GitHub Actions, and Microsoft ships new tools for GitHub first. For customer-specific solutions, the gain is an audit record and no knowledge loss when a developer leaves.


Architecture

Layer What it is Where it runs
AL source code Extension files in VS Code Developer machine / GitHub repo
GitHub repository Branches, PRs, commit history GitHub (cloud or Enterprise)
GitHub Actions / AL-Go Build, test, package pipelines GitHub-hosted or self-hosted runners
BC sandbox environment Test and validation target Business Central cloud sandbox
AppSource or per-tenant deployment Published .app file Business Central tenant

AL runs in Business Central. CI, code review, and packaging run outside it. AL-Go workflows compile the extension, run CodeCop and AppSourceCop, run the AL tests, and can publish to a sandbox or create a release artifact.

The pattern is read-then-write-back through a pipeline. Think of an airport: every passenger goes through the same security check, and there is no side door to the plane. The pipeline is that check for your code. Branch protection enforces it: main accepts a merge only with green CI and an approved review.

AL-specific tooling note: AL-Go for GitHub is Microsoft’s primary CI/CD framework for Business Central. It builds each branch, tests against Business Central containers, and runs scheduled NextMinor and NextMajor checks. The community maintains the Azure DevOps pipelines.


Demo steps

A typical AL-Go flow for a sandbox:

  1. Prerequisites: A GitHub account, VS Code with the AL Language extension, a Business Central sandbox, and a launch.json file that points to it.

  2. Setup: Create a repository from the microsoft/AL-Go-PTE template, which contains the CI and CD workflows.

  3. Development: Create a feature branch, change the AL code, commit, and push.

  4. Pull request: Open a pull request against main. CI builds the app, runs CodeCop and the AL tests, and shows the results.

  5. Review and merge: A second developer reviews. After approval and green checks, merge. The CD workflow builds the .app package and can publish it to the sandbox.

  6. Verification: Install the .app package on the sandbox and test it.

From pull request to validated build usually takes minutes.


What is intentionally simple

  • One extension, one repository, GitHub-hosted runners
  • Minimal tests that validate only the pattern
  • No production gate, security scan, versioning rule, or changelog
  • Packaging only, with no AppSource submission

Risks/limits

  • AL-Go changes often. Update the workflows with each new version, or the repository falls behind.
  • CI is only as good as the tests. Without AL test codeunits, the pipeline checks compilation and static analysis, not behavior.
  • GitHub has a cost. Free Actions minutes are limited. Single sign-on, audit logs, and IP allow lists need an Enterprise plan.
  • Branching needs discipline. Without a convention, parallel work causes merge conflicts that CI cannot solve.
  • Migration from Azure DevOps is complex. Repositories mirror easily. Work items, pipelines, and permissions do not.

Next iteration

  • Add AL tests with real coverage
  • Configure NextMajor validation to find breaking changes early
  • Add secret scanning and CodeQL where they apply
  • Define a release branch strategy, such as release/vX.Y
  • Link GitHub Issues to Azure DevOps work items if you use both

Closing note

The AL extension model made the change possible, and AL-Go removed the tooling barrier. What remains is process and culture. Teams that review every pull request and keep good tests get the value. Teams that use Git only as a backup get the cost.

The release path must go through the pipeline, not around it.

← Back to GitHub