I’m bringing back menus to Business Central

Lately I’ve been thinking a lot about discoverability in my apps and the difficulties with using role centers for “non-role” based apps. So, I have started adding an actual, old-fashioned menu page, and it seems to work quite well. Check out the video:

https://youtu.be/PvEQlkb8Ho4

In this video, Erik demonstrates a practical approach to solving a discoverability problem in Business Central: how to give users a central hub for an app’s features without forcing them to switch Role Centers. He walks through building a custom menu page that serves as a landing page for an app, showing the design pattern and code techniques he’s been using across multiple apps.

The Problem: App Discoverability in Business Central

Business Central is built around the concept of Role Centers — when you open the application, you see a home page tailored to your role. This works great for vertical solutions where someone spends their entire day working within a specific role. But what about utility apps and tools?

Erik’s apps — like the Shopify Connector, Simple Object Designer, and Advanced Cloud Security — aren’t role-based. They’re tools that everyone might use occasionally. Nobody’s job title is “Shopify Connector User” or “Simple Object Designer Operator.” These are things you use for 10 minutes and then go back to your actual work.

The current alternatives are unsatisfying:

  • Creating a Role Center: Counterintuitive because users don’t want to switch their profile just to spend a few minutes configuring security or building a portal.
  • Relying on Tell Me (search): Users have to already know what they’re looking for, which defeats the purpose of discoverability.
  • No central hub at all: Users are left typing the app name in the search bar and getting a scattered list of pages with no context or structure.

Erik points out that in the old Classic client days, there was a Menu Suite object type that provided this kind of structure naturally. That’s long gone, but the need hasn’t disappeared.

The Solution: A Custom Menu Page

Erik has been building custom menu pages that serve as a home screen for each app. He’s already implemented this pattern in the Simple Object Designer (with sections for tasks, data exposure, object customization, and statistics) and in Advanced Cloud Security (where three distinct phases of the security workflow are visually illustrated).

Now he’s applying the same approach to his oldest app, WSFN — a middleware app for building portals, websites, and APIs within Business Central.

How It’s Built: The Technical Approach

Page Type and Setup

The page uses the ListPlus page type, which Erik found renders the nicest for this kind of layout. It runs on the app’s setup table and is locked out of edit mode entirely — this is a navigation page, not a data entry page.

When the page opens, it ensures setup has been completed. If it’s the first time a user opens the app, they’re guided through setup first.

Adding Menu Items as Drill-Down Labels

The core technique for creating clickable menu items is surprisingly simple: you add label fields with drill-down triggers. Here’s the pattern Erik demonstrates:

var
    SecurityProfilesLbl: Label 'Security Profiles';
    UsersLbl: Label 'Users';
    SecuritySettingsLbl: Label 'Security Settings';
    TemplatesLbl: Label 'Templates';

Each menu item is defined as a field on the page with specific properties:

field(SecurityProfiles; SecurityProfilesLbl)
{
    ApplicationArea = All;
    ShowCaption = false;

    trigger OnDrillDown()
    begin
        Page.Run(Page::"W7N Security Profiles");
    end;
}

field(Users; UsersLbl)
{
    ApplicationArea = All;
    ShowCaption = false;

    trigger OnDrillDown()
    begin
        Page.Run(Page::"W7N Users");
    end;
}

field(Templates; TemplatesLbl)
{
    ApplicationArea = All;
    ShowCaption = false;

    trigger OnDrillDown()
    begin
        Page.Run(Page::"W7N Templates");
    end;
}

field(SecuritySettings; SecuritySettingsLbl)
{
    ApplicationArea = All;
    ShowCaption = false;

    trigger OnDrillDown()
    begin
        Page.Run(Page::"W7N Security Settings");
    end;
}

The key details:

  • ShowCaption = false — This is critical. You only want the clickable link text, not a field caption next to it.
  • Label as field source — By binding the field to a Label variable, you get display text that acts as a clickable link.
  • OnDrillDown trigger — This makes the label behave like a drill-down field, opening the target page when clicked.

Layout with Groups and Grids

The menu items are organized using grids and nested groups. Erik notes there’s a rendering quirk where you need to nest a group inside a group inside a grid to get things to display correctly. The items arrange into columns — in the demo, Actions, Security Profiles, and Users form a three-column layout.

Branding with User Controls

Erik adds app logos at the top and bottom of the page using user controls (add-ins). He uses separate user controls for the top and bottom logos because certain properties — particularly sizes — can’t be dynamically specified on user controls in a clean way, so each placement needs its own control definition.

The Menu Structure in Practice

For the WSFN app, the menu page organizes features into logical sections:

  • Setup — Available in the action bar (consistent with Simple Object Designer’s pattern)
  • Actions — Web actions that define portal behavior
  • Security Profiles — Managing access control
  • Security Settings — Filters and rules based on profiles
  • Users — Portal user management
  • Companies — Grouping users into organizations (used for scenarios like car dealership portals)
  • Templates — HTML templates with field insertion, conditionals, and includes (similar to PHP-style templating)

Erik also mentions the potential for adding dashboarding elements — telemetry, user counts, longest running queries — giving the menu page dual purpose as both navigation hub and status overview.

Why Not Role Centers?

Erik is clear about when Role Centers make sense and when they don’t:

  • Role Centers work well for: Vertical solutions, shop floor apps, scenarios where someone lives inside that app all day.
  • Menu pages work well for: Horizontal tools, utilities, apps that any role might use occasionally.

The critical observation is behavioral: Erik simply doesn’t see users switching their profile/Role Center when they need to use a different app. Even when a Role Center is available for an app, people don’t change to it. They stay in their primary role and reach for tools as needed. The menu page respects this reality — you open it, do your work, close it, and you’re back to your role without anything having changed.

Conclusion

This pattern of building custom menu pages addresses a genuine gap in Business Central’s UX for tool-oriented apps. By combining the ListPlus page type, label fields with drill-down triggers, and organized groups and grids, you can create a discoverable, visually structured landing page for your app. It’s a pragmatic middle ground between the heavyweight Role Center approach and the bare-minimum Tell Me search experience — giving users a clear map of what your app can do without asking them to change how they work.

Picture of hougaard

hougaard