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:
-
Prerequisites: A GitHub account, VS Code with the AL Language extension, a Business Central sandbox, and a
launch.jsonfile that points to it. -
Setup: Create a repository from the
microsoft/AL-Go-PTEtemplate, which contains the CI and CD workflows. -
Development: Create a feature branch, change the AL code, commit, and push.
-
Pull request: Open a pull request against
main. CI builds the app, runs CodeCop and the AL tests, and shows the results. -
Review and merge: A second developer reviews. After approval and green checks, merge. The CD workflow builds the
.apppackage and can publish it to the sandbox. -
Verification: Install the
.apppackage 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
NextMajorvalidation 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.