MB-820 is a Business Central developer exam, so treating it like a broad Dynamics 365 assessment creates the wrong study path. Candidates who rely on generic CRM, Finance and Operations, or Marketing material risk missing the developer skills Microsoft actually measures for Business Central.
MB-820 is the Microsoft Dynamics 365 Business Central Developer exam. It is aimed at people who write AL code, build extensions, work with events, integrate Business Central with other services, and understand how customisations are packaged, tested, secured, and deployed in a modern Business Central environment.
Last updated: June 2026. The examples in this article follow current Business Central online extension patterns: AL objects, event subscribers, permission sets, test codeunits, analyzers, and repository-based delivery. Candidates should still check the Microsoft Learn MB-820 exam page before booking, because Microsoft can update measured skills, language availability, exam policies, and retirement information.
What MB-820 Actually Covers
The most useful starting point is the official Microsoft Learn exam page for MB-820, especially the skills measured outline. It defines the exam as a Business Central developer assessment, rather than a general Dynamics 365 or functional consulting exam. The distinction matters because Business Central development has its own object model, extension architecture, AL language patterns, and deployment constraints.
A simple chooser helps avoid wasted preparation time. MB-820 fits candidates who write AL, create pages, tables, reports, queries, codeunits, and extensions, or maintain integrations for Business Central. MB-800 is the more natural path for functional consultants who configure Business Central processes, advise on finance or operations workflows, and do not primarily build code.
That boundary also explains why older preparation habits can be misleading. C/AL-era base application modifications are not a useful exam strategy for the modern developer exam. Business Central SaaS development is extension-led, with custom behaviour added through AL objects, event subscribers, permissions, tests, and controlled deployment processes.
Exam Format: Read the Section Instructions Carefully
Microsoft certification exams can include several question styles, such as multiple choice, case-study-style scenarios, build-list tasks, drag-and-drop items, and other interactive formats. The exact mix can change, so candidates should rely on the current Microsoft Learn MB-820 exam page and Microsoft exam policies rather than memorising a fixed question count or duration from a third-party source.
The backtracking rule is often misunderstood. Some exam sections allow review before final submission, while some scenario, case study, or testlet-style sections may restrict movement once the candidate leaves that section. The safest exam-day habit is to read the introductory screen for each section before answering, because it explains whether questions can be revisited.
Scoring should be treated the same way. Microsoft publishes exam policy guidance, but candidates should avoid assuming that every item has the same weight or that every section behaves identically. Preparation should focus on understanding Business Central development decisions well enough to handle unfamiliar scenarios, rather than trying to reverse-engineer scoring mechanics.
A Developer-Focused Study Plan
Generic exam preparation advice usually starts with practice questions. For MB-820, practice questions are useful only after the candidate can build and explain a working extension. The exam is much easier to reason through when study time is tied to real developer tasks: creating objects, subscribing to events, managing permissions, testing behaviour, and shipping changes through source control.
- Start with the Microsoft Learn MB-820 skills measured outline and mark each topic as familiar, weak, or untested.
- Build a small extension that adds a table, page, page extension, table extension, and codeunit.
- Replace direct modification thinking with event subscriber patterns and document why each event is used.
- Add permission sets and test the extension with a user who does not have broad administrator rights.
- Write automated tests for core behaviour, including setup, assertions, and cleanup considerations.
- Run analyzers locally, fix warnings that affect maintainability or AppSource readiness, and commit the code to a repository.
- Use a simple AL-Go or Azure DevOps pipeline so the project can be built and validated outside the developer’s machine.
This sequence creates a better study loop than reading documentation in isolation. After each lab, the candidate can return to the skills outline and identify which exam objectives the work covered. Readynez discusses this kind of structured preparation in its MB-820 Business Central Developer course, but the same principle applies to any serious study plan: each topic should end in a working, explainable artefact.
AL and Extensions: The Core of the Exam
AL is the language used to create Business Central extensions. Candidates need more than syntax familiarity; they need to understand the object model, object IDs, dependencies, page and table extension behaviour, trigger placement, enums, interfaces, queries, reports, and how source files become a deployable app package.
Event-driven development deserves particular attention. In older systems, customisations often meant changing base application code. In modern Business Central, extensions subscribe to published events so custom behaviour can run without altering Microsoft’s base objects. This reduces upgrade friction and mirrors real SaaS development constraints, which is why event subscriber questions often appear in scenario form rather than as simple definition checks.
The following example shows the shape of a small event subscriber. It is intentionally short: the purpose is to recognise the pattern, not to treat this as a complete production validation design.
Example — AL event subscriber for field validation
codeunit 50110 "Sales Line Validation"
{
[EventSubscriber(ObjectType::Table, Database::"Sales Line", 'OnBeforeValidateEvent', 'Quantity', false, false)]
local procedure CheckQuantityBeforeValidate(var Rec: Record "Sales Line"; var xRec: Record "Sales Line"; CurrFieldNo: Integer)
begin
if Rec.Quantity < 0 then
Error('Quantity cannot be negative.');
end;
}
The subscriber reacts to a table field validation event and applies a rule without editing the base table object. In exam scenarios, the important reasoning is where the logic belongs, what record context is available, and whether the chosen event is stable enough for the requirement.
A common mistake is to skip the official Business Central developer documentation and rely only on copied snippets. That usually leaves gaps around object lifecycle, trigger order, event parameters, permissions, analyzers, and packaging. Candidates who need a refresher on the language itself can review an official Microsoft training path alongside the Business Central developer documentation, then use hands-on labs to turn the concepts into working code.
Permissions, Entitlements, and SaaS Validation
Permissions are often treated as an afterthought during study, but they are central to real Business Central extension work. An extension that works only for SUPER users is not production-ready. MB-820 candidates should know how permission sets support custom tables, pages, reports, and codeunits, and how SaaS validation can expose missing access requirements.
Typical gaps include adding a new table without granting read, insert, modify, or delete permissions where needed; calling code that indirectly touches records the user cannot access; and testing only with a developer or administrator account. A better practice is to create a limited test user, assign the intended permission set, and run the core workflow from that user’s perspective.
Entitlements also matter in SaaS because they help define which users can access capabilities provided by an app. Candidates do not need to turn permissions into a memorisation exercise, but they should be able to explain why extension security must be designed, tested, and packaged rather than patched at the end.
Testing: What Strong MB-820 Preparation Looks Like
Automated testing is one of the clearest differences between shallow and serious MB-820 preparation. A developer who can write a test codeunit, use test pages, prepare fixture data, and make meaningful assertions is better prepared for both the exam and day-to-day Business Central work.
The most frequent testing mistakes are predictable. Tests share state unintentionally, fixture data is too dependent on a specific environment, assertions are missing or vague, and the test checks that code ran rather than checking the business outcome. TestPage usage can also be misunderstood: it is useful for validating page behaviour and user-facing flows, but it should not replace lower-level tests where a codeunit or table-level behaviour is the actual subject.
The next example shows a compact TestPage pattern. In a real project, naming conventions, data isolation, and helper libraries would usually be more disciplined.
Example — AL test codeunit using a TestPage
codeunit 50120 "Customer Page Tests"
{
Subtype = Test;
var
Assert: Codeunit Assert;
[Test]
procedure CustomerNameCanBeUpdatedFromCard()
var
Customer: Record Customer;
CustomerCard: TestPage "Customer Card";
begin
Customer.Init();
Customer."No." := 'BC-TEST-001';
Customer.Name := 'Business Central Test Customer';
Customer.Insert(true);
CustomerCard.OpenEdit();
CustomerCard.GoToRecord(Customer);
CustomerCard.Name.SetValue('Updated Test Customer');
Customer.Get('BC-TEST-001');
Assert.AreEqual('Updated Test Customer', Customer.Name, 'The customer name should be saved.');
end;
}
This test creates a record, opens the customer card as a test page, changes a value, and verifies the persisted result. The learning point is the discipline around setup and assertion. A test without a clear assertion may give false confidence, while a test that depends on existing environment data can fail for reasons unrelated to the extension.
CI/CD, Analyzers, and Release Discipline
MB-820 is not a DevOps certification, but Business Central developers still need to understand how extensions move from local development to validation and deployment. A practical study project should use a repository, build outside the local machine, and run the same analyzers that a team would rely on before release.
CodeCop and AppSourceCop warnings are worth taking seriously during preparation. They often surface design issues that also matter in exam scenarios: naming, object ranges, breaking changes, obsolete patterns, missing captions, and AppSource readiness. Treating analyzer warnings as optional noise is one of the easiest ways to build habits that do not transfer well to professional Business Central development.
A simple CI/CD path is enough for exam preparation. Store the AL project in source control, enable analyzers, build the app in a pipeline using AL-Go or Azure DevOps, publish build artefacts, and handle signing or deployment credentials through secure secret storage rather than committed configuration files. Candidates who want a deeper pipeline walkthrough can continue with ongoing Microsoft training options after they have the basic build loop working.
Telemetry is another area candidates often overlook. Business Central extensions should be diagnosable after deployment, especially when operations are long-running or depend on external systems. Understanding how application telemetry supports troubleshooting gives developers a more realistic view of extension quality than a local-only test cycle can provide.
Practice Questions Are Useful After the Labs
Practice exams can help with timing, wording, and confidence, but they should not become the main learning method. MB-820 questions often test judgment: which event is appropriate, where permissions should be defined, how an integration should be structured, or why a test is failing. Those answers are easier to recognise after the candidate has built similar patterns.
Study groups can help when they focus on explaining decisions rather than trading answers. A useful discussion might compare two possible event subscribers, examine why a permission set failed validation, or review an analyzer warning. By contrast, memorising question dumps is unreliable, violates exam ethics, and does little to build Business Central development skill.
Preparing for Exam Day
In the final phase, candidates should reduce uncertainty rather than add new material. The official Microsoft exam policies explain identification, scheduling, rescheduling, retake rules, and online or test-centre expectations. The MB-820 exam page remains the source of truth for current skills measured, availability, and policy links.
A strong final review is practical and focused. Rebuild the study extension from a clean checkout, run analyzers, execute tests, verify permissions with a limited user, and review notes on events, integrations, deployment, and security. If a topic cannot be explained without opening documentation, it deserves another short lab rather than another passive reading session.
Where MB-820 Preparation Should Lead
Good MB-820 preparation produces more than exam familiarity. It builds the working habits expected of Business Central developers: extension-first design, event-driven customisation, secure permissions, repeatable testing, clean builds, and an awareness of maintainability after deployment.
The most effective next step is to compare the Microsoft skills measured outline with a real extension project and close the gaps one by one. Readers who want a more guided route can explore Readynez for advice on MB-820 preparation, but the foundation remains the same: build, test, secure, and deploy Business Central extensions until the exam scenarios feel familiar rather than abstract.
FAQ
What is the MB-820 exam for?
MB-820 is for Microsoft Dynamics 365 Business Central developers. It focuses on AL development, extensions, events, integrations, security, testing, and deployment concepts for Business Central, rather than Finance and Operations, Marketing, or purely functional consulting topics.
How should a developer prepare for MB-820?
A developer should start with the Microsoft Learn MB-820 skills measured outline, then build a small Business Central extension that covers common object types, event subscribers, permissions, tests, analyzers, and a basic CI/CD workflow. Practice questions are most useful after those hands-on gaps have been addressed.
Can candidates go back to previous questions during MB-820?
It depends on the exam section. Some sections may allow review, while some scenario, case study, or testlet-style sections may restrict backtracking once the candidate leaves them. Candidates should read each section introduction carefully during the exam.
What are common MB-820 preparation mistakes?
Common mistakes include studying the wrong Dynamics 365 product, relying on C/AL-era base modification concepts, skipping events and subscribers, ignoring CodeCop or AppSourceCop warnings, testing only with administrator permissions, and neglecting automated tests.
Are practice tests enough for MB-820?
Practice tests are helpful for exam rhythm and question style, but they are not enough on their own. MB-820 preparation should include hands-on AL development, extension packaging, permissions validation, automated testing, and repository-based build practice.
