Coverage Pack — one-time build service

Your core processes have no test coverage. Nobody on the team is going to build it.

We build parameterized test scripts for your core Business Central business processes — built to match how your team actually works, not how Microsoft’s demo data works. Then we keep them running through every wave.

See pricing Is my setup Custom?

3 processes from $2,995 · 5 processes from $4,295 · scripts delivered as .yml files you own

What you are buying

What a business process means here

You buy coverage by business process. Each one expands into the scenarios your team actually runs.

Business Process
Order-to-Cash
Test Scenario
Post shipment, partial qty
Script
order-to-cash.yml
Step
Invoke “Post” on page 42

One business process typically expands to 3–8 test scenarios: the happy path, the partial shipment, the credit hold, the wrong-currency customer. So a 5-process pack is usually 20–40 scenarios — and with parameterization, far more validated runs.

Built around your team

Built the way you actually work

Two click paths, same posted result. A generic template only tests one of them — and it is usually the one your team never uses.

Path A — Microsoft’s demo path
New Sales Order from the Sales Orders list
  1. Search → Sales Orders
  2. Action bar → New
  3. Fill Customer No., lines
  4. Post → Ship and Invoice
[Asset B — screenshot: Sales Orders list → New]
Path B — how your order desk works
New Sales Order from the Customer Card
  1. Search → Customers → open card
  2. New Document → Sales Order
  3. Customer pre-filled; add lines
  4. Post → Ship and Invoice
[Asset B — screenshot: Customer Card → New Document → Sales Order]

Same posted sales invoice. Different pages, different actions, different places for a wave to break something. Your users take Path B every day, so Path B is the script we build.

We don’t ship you a template. We watch how your team works, then build scripts that break when your process breaks — not when Microsoft’s demo data changes.

The multiplier effect

One script. Twelve rows. Sixty validated scenarios.

A recorded Page Scripting file tests one customer, one item, one quantity. We parameterize it so the same script runs against a data table — and every row is a scenario that would otherwise need its own recording.

1
Order-to-Cash script
×
5
parameter axes
×
12
data rows
=
60
validated scenarios
RowCustomerItemLocationCurrencyQuantity
110000 Adatum Corporation1896-S ATHENS DeskMAINUSD1
210000 Adatum Corporation1896-S ATHENS DeskMAINUSD25
320000 Trey Research1900-S PARIS Guest ChairEASTUSD4
420000 Trey Research1920-S ANTWERP Conference TableEASTUSD2
530000 School of Fine Art1928-S AMSTERDAM LampMAINUSD12
630000 School of Fine Art1896-S ATHENS DeskWESTUSD1
740000 Alpine Ski House1900-S PARIS Guest ChairMAINEUR6
840000 Alpine Ski House1964-S TOKYO Guest ChairWESTEUR10
950000 Relecloud1920-S ANTWERP Conference TableEASTGBP1
1050000 Relecloud1928-S AMSTERDAM LampMAINGBP3
1160000 Coho Winery1996-S ATLANTA WhiteboardWESTUSD8
1260000 Coho Winery1896-S ATHENS DeskEASTUSD40

Each row exercises the same posting routine with different master data: a foreign-currency customer, a location with bin mandatory, a quantity that triggers a partial shipment. Five parameter axes across twelve rows validate sixty combinations of customer, item, location, currency and quantity from one maintained script. Knowing which axes matter for your data is what the discovery session is for — it is not something you get from watching a Microsoft demo.

How it works

Four steps from no coverage to every wave covered

1

Discovery — one hour per process

Before the session, you record yourself doing the process once with Page Scripting and send us the recording. In the hour, we review it together and agree where the parameters belong and which scenarios matter.

2

Build

We build and parameterize the scripts, add validations that check what the recording only clicked through, and map every scenario in a coverage matrix.

3

Baseline

First full run against your sandbox. You get the results report — pass/fail by scenario, step timing, video — and a 60-minute handoff session.

4

Ongoing — Update Validation

Scripts run against every Microsoft preview and release. When a wave changes a page or removes an action, we repair the scripts we built and you get the report before your users notice anything.

[Asset E — sample run report: the recurring deliverable prospects subscribe to receive]

Pricing

Build coverage once. Keep it validated every wave.

Two parts: a one-time Coverage Pack that builds your scripts, and an Update Validation subscription that keeps them working through every Microsoft release.

1 — Setup: Coverage Pack (one-time)

3 Processes
$2,995 one-time

Three business processes, scripted and parameterized

  • Discovery3 × 1 hour
  • Scripts built3
  • Your own scriptsUnlimited
  • Wave repairIncluded, for processes we build
Get started
Custom
Contact us

More than 10 processes, ISV-driven UI, warehouse, manufacturing, intercompany

  • DiscoveryScoped
  • Scripts builtScoped
  • Your own scriptsUnlimited
  • Wave repairIncluded, for processes we build
Talk to us
Bring Your Own Scripts
No setup fee. Upload and run unlimited Page Scripting scripts on the platform. You maintain them; repair is available at $350 per script. Subscription rates as below.
Start self-service

2 — Subscription: Update Validation (recurring)

Every path includes it. Your scripts run against every Microsoft preview and release; we repair what Microsoft breaks in the processes we built.
$200/month per company
Billed annually · $2,400 total commitment

A six-month term spans a full Microsoft release cycle, including preview validation. Twelve months covers both waves of the year at the lower rate.

  • Runs against every preview and release
  • Video of every run, step-level logs
  • Run history and pass/fail trends
  • Repair of scripts we built
  • Unlimited scripts on every plan
  • Priority email support

Example: 5 Processes + 12-month Update Validation = $4,295 today, then $200/month per company.

Scope

What’s included, what’s not

Included
  • Discovery sessions, one hour per business process
  • Script build and parameterization
  • Coverage matrix: scenarios mapped to processes
  • Baseline run report
  • 60-minute handoff session
  • Scripts delivered as .yml files the customer owns
Not included
  • Remediation of issues the tests find
  • AL code changes
  • ISV app configuration
  • Performance or load testing
  • Processes requiring data that doesn’t exist in the sandbox
  • Maintenance of scripts we didn’t build
[Asset D — sample coverage matrix, redacted]

Before we start

Prerequisites

These are your side of the build. The delivery clock starts when they are met.

  • Sandbox environment refreshed from production
  • Representative master data that can be posted against — customers, items, locations, open periods
  • One named SME available for the discovery sessions
  • Environment access and test user credentials provisioned
  • A rough Page Scripting recording of each process, sent before its discovery session

Questions

Frequently asked

What happens when Microsoft changes a page?

Your scripts run against the preview environment before the wave ships. If Microsoft renames an action, moves a field or removes a report, the affected step fails, you see it on video, and we repair the script as part of Update Validation — for every process we built.

Who owns the scripts?

You do. Every script is delivered as a Page Scripting .yml file in your account. If you leave, the scripts leave with you and still run in BC’s built-in tool.

What if our process changes?

If your team changes how it works — a new approval step, a different posting page — that is a scope change, not a repair. Small changes are usually covered by an additional discovery session ($350); larger ones are quoted as new processes.

Why not just use the free Page Scripting tool ourselves?

You can, and Bring Your Own Scripts exists for exactly that. The tool records one path with one set of data. Parameterization, validations beyond click-through, a coverage matrix and repair after every wave are the work — and the part nobody internally has time to own.

What counts as one business process?

One end-to-end flow with one posted outcome: Order-to-Cash, Procure-to-Pay, a bank reconciliation, a month-end close routine. Each expands to 3–8 scenarios. The Process Library lists the eight standard ones and the rule for when a process is Custom.

Can we upload our own scripts too?

Yes — unlimited, on any plan. We maintain the ones we built; you maintain yours. Repair of a customer-authored script is available at $350 per script.

What if we edit a script you built?

It becomes yours to maintain from that point. Wave repair covers scripts in the state we delivered them; if an edited script breaks, repair is $350 per script or we can rebuild it in the next discovery session.

Get coverage before the next wave

3 processes for $2,995. 5 processes for $4,295. Custom scoped in one call.

Start with 5 processes Start with 3 processes Scope a Custom pack