MB-820 is the certification exam for Dynamics 365 Business Central developers, assessing the AL skills used to build extension-based, upgrade-safe solutions rather than directly customising the base application.
The Microsoft MB-820 exam is aimed at developers who design, build, test, secure and maintain Business Central apps using AL, Visual Studio Code and the Business Central development toolchain. Microsoft Learn remains the source of record for the current exam objectives, policies and scheduling details, so preparation should start with the MB-820 exam page and then move quickly into hands-on work.
What MB-820 actually measures
MB-820 is the developer counterpart to the functional Business Central path. MB-800 focuses on the Business Central Functional Consultant role, while MB-820 focuses on the developer tasks behind extensions: data model changes, pages, reports, XMLports, queries, codeunits, permissions, testing and deployment. That distinction matters because many candidates prepare too broadly for Business Central and too lightly for AL development.
In practical terms, the exam maps closely to common extension work. Tables and table extensions support changes to the data model; pages and page extensions shape the user experience; reports, XMLports and queries handle output, analysis and data exchange; codeunits contain business logic; and permissions determine whether users can safely access the new objects. The Microsoft Business Central developer documentation and AL language reference are useful companions here because they explain the platform concepts behind these tasks without relying on exam shortcuts.
Candidates should also expect Microsoft exam formats that test judgement as well as recall. Microsoft certification exams commonly use multiple choice, multiple response, case-based scenarios, drag-and-drop and interactive item types, depending on the exam delivery at the time. The safest tactic is to read the scenario first, identify the constraint, and then eliminate answers that would break SaaS compatibility, security boundaries or upgrade-safe extension patterns.
Readers who want a structured lab-led path can use the MB-820 Business Central Developer course as one option, but the core preparation still needs to include regular development practice in a real Business Central environment.
Build the right development environment before studying deeply
Preparation becomes much easier when the candidate can test every concept rather than only read about it. A basic MB-820 lab should include Visual Studio Code, the AL Language extension, access to a Business Central sandbox, a small extension project, test data and version control. This setup turns exam topics into concrete developer habits: downloading symbols, resolving dependencies, publishing apps, debugging code and checking that permissions work as intended.
A SaaS sandbox is usually the most relevant environment for MB-820 practice because Business Central development increasingly assumes cloud constraints. It exposes candidates to the limitations that appear in real projects, such as avoiding direct file system assumptions, designing for background sessions carefully and keeping long-running operations under control. Docker-based environments can still be useful for isolated experiments, older version testing or repeatable local labs, but candidates should avoid building habits that only work outside Business Central online.
Managing symbols and dependencies is one area where learners often lose time. When an extension references another app, the app.json dependencies must align with what is installed in the target environment, and symbols should be refreshed when platform or application versions change. In practice, this is where source control and a simple CI process prevent many avoidable errors.
AL-Go for GitHub is worth understanding at an exam-relevant level. Candidates do not need to memorise every pipeline detail, but they should understand why automated builds, tests and packaging help catch breaking changes before an extension reaches a sandbox or production environment. This also reinforces the difference between per-tenant extensions and AppSource apps, where signing, validation and lifecycle expectations become more formal.
AL objects make more sense when studied as workflows
AL objects are easier to remember when they are connected to the business workflow they support. A table extension adds data to a record, a page extension exposes that data to users, a codeunit applies rules or reacts to events, and a permission set controls access. Microsoft’s AL language reference is useful here because it shows the syntax, but exam readiness comes from knowing when a particular object is the right design choice.
Business Central developers should favour events and extensions over invasive customisations. Event subscribers make code easier to isolate and upgrade, but they introduce their own judgement calls: event ordering can be non-deterministic, subscribers should avoid hidden side effects, and business logic should remain understandable when more than one extension responds to the same event. These are practical concerns, and they are also the kind of reasoning that scenario questions tend to reward.
The following example shows a small table extension. It is useful when practising how an extension adds a field without changing the base application object.
Example — Add a customer review field
tableextension 50100 CustomerReviewExt extends Customer
{
fields
{
field(50100; "Credit Review Required"; Boolean)
{
Caption = 'Credit Review Required';
DataClassification = CustomerContent;
}
}
}
The important learning point is not the field itself. The field becomes exam-relevant when the candidate can explain how it should appear on a page, how it should be protected with permissions, how it behaves during upgrades and how dependent code should validate changes before storing them.
A common AL mistake is to treat Insert, Modify and Validate as interchangeable. Validate runs field validation logic and can trigger related business rules, while direct assignment followed by Modify may bypass important behaviour. Good preparation includes testing both approaches in a sandbox so that the candidate understands the consequence rather than memorising a rule.
The next example uses an event subscriber to react after a customer name is validated. It demonstrates the event-driven approach that is more upgrade-safe than altering standard application code.
Example — React to a customer validation event
codeunit 50101 CustomerReviewSubscriber
{
[EventSubscriber(ObjectType::Table, Database::Customer, 'OnAfterValidateEvent', 'Name', false, false)]
local procedure CustomerNameOnAfterValidate(var Rec: Record Customer; var xRec: Record Customer; CurrFieldNo: Integer)
begin
if Rec.Name <> xRec.Name then
Rec."Credit Review Required" := true;
end;
}
This pattern helps candidates connect syntax to design. The subscriber responds to a platform event, changes extension-owned data and leaves the base application intact. In a real app, the next checks would include whether the field is shown on the right page, whether the user has permission to update it and whether additional validation is needed before the record is saved.
Security and performance are part of development, not separate topics
Security questions in MB-820 preparation should not be treated as memorisation exercises. Permission set v2, entitlements and object permissions influence whether an extension can be used safely after deployment. A feature that works for a developer with broad permissions may fail for an end user if permission sets are incomplete, and that failure can be difficult to diagnose if security is added late.
Performance has a similar pattern. Queries, reports and record filtering should be designed with the data volume and user task in mind. Candidates should practise SetRange and SetFilter carefully, understand when filters are too broad, and avoid pulling unnecessary records into AL code when a query or filtered record variable would do the work more efficiently.
Telemetry is another practical area that deserves attention. Business Central can emit signals that help teams understand extension behaviour, failures and performance characteristics, often through Application Insights. For the exam, the key point is that maintainable apps are observable apps; for the workplace, telemetry can shorten the time between a production issue and a useful diagnosis.
A practical MB-820 study plan
An effective study plan should alternate between Microsoft Learn objectives, documentation, AL coding and review questions. The weak approach is to read all the theory first and postpone development until the end. A better rhythm is to study one skill area, build a small version of it, break it deliberately, fix it and then write down the rule that would help in an exam scenario.
The following sequence gives preparation enough structure without turning it into a checklist-driven exercise:
- Read the current MB-820 skills outline on Microsoft Learn and identify unfamiliar AL object types.
- Create a VS Code AL project and publish a small extension to a Business Central sandbox.
- Add a table extension, page extension, codeunit, query and permission set to connect syntax with user behaviour.
- Practise debugging, dependency handling and symbol refreshes after changing the app or environment.
- Review Microsoft Business Central developer documentation for areas where the lab exposed uncertainty.
- Answer scenario questions by identifying the constraint before choosing an implementation option.
A sample question might describe an extension that updates records directly when a related field changes and ask which approach better preserves standard validation logic. The strongest answer would usually favour invoking validation where business rules need to run, rather than bypassing that logic with direct field assignment. The rationale is what matters: Business Central apps should preserve platform behaviour unless there is a clear, controlled reason not to.
Consultants moving from MB-800 to MB-820 should spend extra time translating functional understanding into developer implementation. Knowing what a user needs is valuable, but MB-820 expects the candidate to know how the requirement becomes AL objects, tests, permissions and deployment artefacts. Hiring managers can use the same distinction when evaluating readiness: a strong MB-820 candidate should be able to discuss design choices, not only navigate the application.
Exam-day judgement and review tactics
Good exam technique starts with respecting the wording of each question. Microsoft scenarios often contain constraints such as online deployment, least privilege access, upgrade requirements or integration behaviour. Those details should drive the answer, especially when more than one option appears technically possible.
It is also useful to mark uncertain questions for review rather than spending too long on a single scenario. When returning to them, candidates should re-read the final sentence first, then the scenario, and then the answers. This helps separate the actual requirement from distracting details.
Preparation should avoid braindumps and memorised answer banks. They can violate exam rules, become outdated quickly and fail to build the judgement needed for scenario-based questions. A safer approach is to practise with legitimate sample questions, explain why each wrong answer is wrong, and keep a short error log of concepts that need another lab session.
Where MB-820 preparation fits next
MB-820 preparation is strongest when it builds habits that survive the exam: extension-first design, careful validation, explicit permissions, source control, automated checks and attention to telemetry. These habits help developers build Business Central apps that can be upgraded, supported and reviewed by other team members.
Developers planning a broader Microsoft learning path can compare related options through Microsoft training courses or consider Unlimited Microsoft Training by Readynez when multiple exams or roles are part of the same plan. Questions about the MB-820 path, training fit or team readiness can also be directed through the contact page.
The most effective next step is to build a small extension and use it as the anchor for study. If a candidate can explain why each object exists, how it is secured, how it is deployed and how it behaves under Business Central online constraints, the exam content becomes much easier to reason through.
FAQ
What is the Microsoft MB-820 exam for?
MB-820 is the Microsoft exam for the Dynamics 365 Business Central Developer role. It validates the ability to develop, extend, test and maintain Business Central apps using AL and related development tools.
Is MB-820 the same as MB-800?
No. MB-800 is aligned with the Business Central Functional Consultant role, while MB-820 is aligned with the Business Central Developer role. A functional consultant focuses on business configuration and process fit; a developer focuses on extensions, AL objects, integrations, security and app lifecycle tasks.
What tools should be used when preparing for MB-820?
Candidates should practise with Visual Studio Code, the AL Language extension, a Business Central sandbox and source control. A Docker-based environment can be useful for certain local experiments, but a SaaS sandbox is often closer to the cloud constraints developers must understand.
What question types should candidates expect?
Microsoft exams may include multiple choice, multiple response, case-based scenarios, drag-and-drop and other interactive formats. Candidates should use the current Microsoft exam page for official details and should prepare by practising scenario analysis rather than memorising answer patterns.
How much AL experience is needed before taking MB-820?
There is no useful substitute for hands-on AL practice. A candidate should be comfortable creating and publishing a small extension, working with tables, pages, codeunits, queries and permissions, and explaining how the app would be tested and deployed.
