Today we release a new app for Business Central. The ToolBox is the supporter’s best friend. A way to easily write a few lines of AL code, and run that code inside BC. The perfect tool to handle all supports cases that used to require deployments of extensions. Read more here and check out the introduction video:
OBS: An issue that prevents opening the ToolBox has been identified, and an update is submitted to AppSource. If you encounter this issue, please await the app update.
Erik’s Toolbox is a powerful extension for Dynamics 365 Business Central that lets you write, compile, and execute AL code directly inside Business Central — without deploying extensions. In this introductory video, Erik demonstrates how the toolbox works, including writing and running AL programs, working with Excel data, managing user access levels, and maintaining a complete audit trail of all operations.
The Problem: A Missing Tool for Business Central
If you’ve worked with Business Central, you’ve likely encountered situations where you need to do something for a customer that the standard UI simply doesn’t support. In the old NAV days, there were tools available to handle these one-off tasks. But with Business Central, your only option has been to fire up Visual Studio Code, connect to a sandbox, build an extension, deploy it to production, and hope it works the first time.
Erik’s Toolbox fills that gap. It’s a tool Erik has been using in various forms for over a year and a half, and it’s now available as a polished product for anyone working with Business Central.
How the Toolbox Works
When you open the Toolbox, you’re presented with a simple two-pane interface: write AL code on the left side, and see results on the right. This is not an extension deployment — the code compiles and executes entirely in memory inside Business Central. There’s no uploading, no deployment, no waiting.
Writing and Running Your First Program
You can start with something as simple as a Message call:
Message('Hello');
Hit Run, and the code compiles and executes immediately. By default, with console output enabled, messages appear in the output panel on the right side. Turn off console mode, and you get the standard Business Central message dialog instead — useful when you only have a single output, but the console mode is far more convenient when working with multiple messages.
You can build more complete programs with variable declarations, record types, and full IntelliSense support:
var
Customer: Record Customer;
begin
Customer.FindFirst();
Message('Hello %1', Customer.Name);
end;
IntelliSense provides table names, field names, and method suggestions, making it feel like a lightweight version of Visual Studio Code right inside Business Central. If you make a mistake, you get proper compile errors with line numbers — just like you’d expect from any development environment.
Saving and Loading Programs
Programs can be saved with descriptive names and loaded later. This means you can build up a library of useful scripts for common tasks. The Toolbox also supports sharing programs across environments: if you work with multiple customers, sandboxes, or production environments, you can mark a program as shared, and it becomes available everywhere you run the Toolbox. Sharing is handled through an Azure Storage Account.
Built-in Excel Integration
One of the most practical features of the Toolbox is its native Excel integration. As Erik puts it, in support scenarios there’s almost always an Excel sheet involved.
Writing to Excel
The Toolbox introduces special commands for working with Excel. The XSet command sets a value at a specific row and column:
XSet(Row, Column, Value);
For example, you can loop through customers, calculate balances, and output the results to an Excel sheet. Click the Excel tab in the Toolbox to see the generated spreadsheet, and then download it — all without leaving Business Central.
Reading from Excel
The real power shows up in the reverse direction. A common scenario: a customer sends an Excel file saying “Here’s a list of customer numbers in column D, rows 6 through 10, with new credit limits in column E. Please update them.”
You can upload that Excel file into the Toolbox, then write a program to read from it and update records:
var
Customer: Record Customer;
i: Integer;
d: Decimal;
begin
for i := 6 to 10 do begin
Customer.Get(XGet(i, 4));
Evaluate(d, XGet(i, 5));
Customer.Validate("Credit Limit (LCY)", d);
Customer.Modify(true);
end;
end;
The XGet command retrieves a value from the uploaded Excel sheet at a given row and column. Since Excel values come in as strings, you use Evaluate to convert them to the appropriate data type. A smart approach is to first output the values with Message to verify everything looks correct before adding the Modify call — a built-in “dry run” workflow.
User Access and Security
Security is a core concern with a tool this powerful. The Toolbox has multiple layers of access control.
Prerequisites
To use the Toolbox at all, you must be a Super user in the Business Central environment. On top of that, users need explicit access within the Toolbox itself.
Three Access Levels
- God Mode — Full access to everything, including restricted tables like ledger entries and other sensitive data. The first user to open the Toolbox is automatically assigned God Mode.
- Write Normal Tables — Can read and write to standard tables but cannot access restricted tables that normally require extra permissions.
- Read Only — Can execute programs that read data but cannot modify anything.
God Mode Warnings
When running in God Mode and your code attempts to modify a restricted table, the Toolbox presents a warning dialog with three options:
- Allow Always — Suppresses the warning for this table going forward (does not suppress logging)
- Allow This Session — Useful when modifying many records in the same table, so you don’t have to confirm a thousand times
- Don’t Allow — Aborts the operation
Complete Audit Trail
Every action taken in the Toolbox is recorded. From the setup screen, you can view the audit trail for any user, seeing exactly what programs were executed and when.
For God Mode operations — any time code touches a restricted table — the audit trail includes the full source code that was executed. The logging is efficient: if your program modifies a thousand records in one table, you get a single audit entry noting that a user touched that table with a specific piece of code, not a thousand individual entries.
This is actually a significant advantage over the traditional approach. If someone deploys a temporary extension to make changes and then removes it, there’s no trace of what happened. With the Toolbox, every operation is documented and auditable.
Project Structure
Looking at the source repository, Erik’s Toolbox is structured as a standard AL project with a workspace configuration that includes the main app, tests, scripts, and CI/CD pipelines:
{
"folders": [
{ "path": "app" },
{ "path": "test" },
{ "path": "scripts" },
{ "path": ".github" },
{ "path": ".azureDevOps" }
],
"settings": {
"al.enableCodeAnalysis": true,
"al.codeAnalyzers": [
"${CodeCop}", "${UICop}", "${PerTenantExtensionCop}"
]
}
}
The project uses Azure DevOps pipelines for continuous integration, compiling against multiple artifact versions (Current, Next Minor, and Next Major) and multiple localizations (W1 and US) to ensure compatibility:
strategy:
matrix:
'Compile Against W1 - Current Version':
artifactCountry: 'w1'
artifactVersion: 'Current'
'Compile Against W1 - Next Minor':
artifactCountry: 'w1'
artifactVersion: 'NextMinor'
'Compile Against W1 - Next Major':
artifactCountry: 'w1'
artifactVersion: 'NextMajor'
'Compile Against United States - Current Version':
artifactCountry: 'us'
artifactVersion: 'Current'
'Compile Against United States - Next Minor':
artifactCountry: 'us'
artifactVersion: 'NextMinor'
'Compile Against United States - Next Major':
artifactCountry: 'us'
artifactVersion: 'NextMajor'
Code analysis is enforced with failonwarnings: true, ensuring high code quality standards. The project is licensed under the MIT License.
Summary
Erik’s Toolbox brings back the kind of direct, interactive coding experience that Business Central consultants and developers lost when moving from NAV. Key features include:
- In-memory AL execution — Write and run AL code instantly without building or deploying extensions
- Full IntelliSense — Table names, field names, and method suggestions right in the browser
- Excel integration — Read from and write to Excel sheets with simple
XGetandXSetcommands - Program library — Save, load, and share programs across environments via Azure Storage
- Granular security — Three access levels (God Mode, Write Normal Tables, Read Only) with per-user control
- Complete audit trail — Every execution is logged, with full source code recorded for sensitive operations
Whether you’re doing a quick data fix, investigating an issue, or handling a bulk update from a customer’s Excel file, Erik’s Toolbox eliminates the overhead of the traditional extension development cycle and gives you a safe, auditable way to get the job done.
