Automated testing

Every change in Business Central should create value—not worry. With automated tests, you get a safety net that catches regressions before they reach users. We identify your critical flows (e.g., O2C and P2P), translate them into reusable test scenarios, and hook them into your build and release process so quality becomes a habit—not a happy accident. The result is predictable updates, shorter test cycles, and documented confidence with every release. You gain transparency through reports and alerts, and a test suite that keeps pace as the business evolves. Together, we keep you “standard first” and test precisely where you have customisations and the highest risk.

When the solution evolves, it must still work

In Business Central, things change continuously. New features, new integrations and ongoing updates from Microsoft.

Microsoft releases two major Business Central updates a year, alongside monthly hotfixes, new Copilot capabilities and changes to underlying APIs. Every update can affect your customisations, integrations and business-critical flows in Q2C and P2P. Without a plan for how the solution is tested and maintained between releases, problems only surface when an order fails or an invoice cannot be posted. We build automated testing into your Business Central solution so the critical scenarios are validated at every release, before they reach production. Combined with our Keep Current service, this means you keep pace with Microsoft's release cycle without losing stability, and without each update turning into a project of its own.

In modern solutions, everything is connected.

A change in one place can affect something completely different elsewhere.

This happens because the solution has been developed over time, with many dependencies along the way. Requirements change, new needs emerge, and the solution is adjusted continuously.

At the same time, smaller adjustments are often made by different developers over time.

This is a natural part of development, but it also means that the structure of the code can gradually become less consistent and more complex.

The more the solution grows, the harder it becomes to keep a full overview.

Even small changes can therefore have consequences that only surface once the solution is in use.

Automated tests change that picture.

They do not only ensure that functionality works, they also help keep the solution healthy over time.

When tests become a fixed part of development, it becomes clear where the solution can be improved.

This often leads to refactoring and a more structured codebase, which makes the solution less vulnerable and easier to build on.

Historical development vs. continuous testing

When tests do not keep up

Typical experience:

  • Changes affect unforeseen parts of the solution

  • Testing is manual and depends on the individual developer

  • Previous functionality is not consistently verified

  • Errors are only discovered when users hit them

  • The solution gradually becomes more vulnerable

When tests are part of the solution

What this means in practice:

  • Changes are verified across the entire solution

  • Tests run automatically every time something changes

  • Existing functionality is protected systematically

  • Errors are caught before they reach users

  • The solution stays stable, even as it evolves

Automated tests change the way you work with the solution.

Instead of testing what was just changed, the entire solution is verified continuously. The most important processes are reviewed again and again, without depending on who remembers what.

At the same time, it becomes clear how the solution actually works.

When tests describe concrete scenarios, they become a shared reference for both developers and the business. This creates a shared understanding of what should happen, and what is expected in practice.

Tests become a natural part of the documentation of how the solution should work.

Want to know more about Automated Testing?

Keep Current and Automated Testing secure the stability of your PTE app

Automated testing in Microsoft Dynamics 365 Business Central is coded test scenarios that run automatically to verify that functionality, customisations and integrations work as expected. Tests are written as AL test codeunits using Microsoft's Test Toolkit and Test Runner, and they can cover everything from individual functions (unit tests) to full business flows such as Quote-to-Cash and Procure-to-Pay (integration tests). Tests run at every code change or release and replace manual testing, which is time-consuming and does not scale with frequent Business Central updates.

The Microsoft Test Toolkit is a built-in framework in Business Central that makes it possible to write, run and report on automated tests written in AL. The toolkit consists of Test Runner, Test Isolation, Permission Mock, Library Assert and a set of reusable test libraries from Microsoft. It supports unit tests, integration tests and scenario tests, and integrates directly with Visual Studio Code, AL-Go for GitHub and Azure DevOps Pipelines for CI/CD workflows.

Regression testing is automated verification that existing functionality still works after code changes, Microsoft updates or new extension installations. In Business Central, regression testing is especially critical because Microsoft ships two major releases a year (April and October), and every release can affect customisations, PTE apps and integrations. An automated regression test suite runs business-critical flows end to end in a test environment before production and catches errors before end users encounter them.

Automated tests are prioritised for business-critical flows, customisations and integrations, not for Microsoft's standard functionality, which is already tested by Microsoft. Typical areas are Quote-to-Cash (quote, order, delivery, invoicing, payment), Procure-to-Pay (requisition, purchase order, goods receipt, 3-way match), inventory management, manufacturing, financial close, VAT reporting and every integration to external systems such as e-commerce, EDI, warehouse WMS and payment platforms.

Unit tests verify a single function or codeunit in isolation, typically without database calls or dependencies on other modules, and run in milliseconds. Integration tests verify the interaction between multiple codeunits, tables and modules in Business Central, for example the full Quote-to-Cash flow from sales order to general ledger posting. Unit tests catch logical errors early in development, while integration tests catch errors in how components work together, and they usually run in CI/CD pipelines before release.

Setting up automated testing for Business Central typically costs between 10,000 and 70,000 EUR depending on the number of processes, the complexity of customisations and integrations, and the required coverage level. Setup includes analysis of critical flows, building a test library in AL, configuring Test Runner, integration with the CI/CD pipeline and documentation. Ongoing maintenance is typically 10 to 20 percent of the setup cost per year. CURABIS provides a fixed price after an initial assessment of the existing codebase and testing needs.

Keep Current is a maintenance service that automatically adapts PTE apps (Per Tenant Extensions) and customer-specific extensions to Microsoft's two annual Business Central releases. The service ensures that apps remain compatible with new versions, that deprecated APIs are replaced, and that breaking changes are handled before the release. CURABIS delivers Keep Current together with automated testing, so every release is validated against the full solution's critical flows before going into production.

Automated tests are integrated into a Business Central CI/CD pipeline through AL-Go for GitHub or Azure DevOps Pipelines. On every pull request, the extension package is built and the full test library is executed automatically against a fresh Business Central test environment. Test results are reported back as status checks, and deployment to production is blocked if tests fail. This means every code change is validated before it reaches users, and Microsoft's biannual updates can be tested in advance against the full solution.