Category: App Development

🚀 Copilot and AL Development: Transforming the Future of Business Central Engineering

The world of Business Central development is evolving rapidly—and one of the most powerful accelerators in recent years is Copilot. With AI deeply integrated into the Microsoft ecosystem, developers building extensions with AL now have an intelligent partner that speeds up development, enhances accuracy, and improves productivity.

🧠 What Is Copilot in Business Central?

Copilot is Microsoft’s AI-powered assistant designed to help developers, consultants, and end-users across Dynamics 365. For Business Central development, Copilot works in multiple ways:

  • Suggesting AL code in VS Code
  • Generating complete extension structures (tables, pages, APIs, codeunits)
  • Helping analyze and explain existing AL code
  • Creating documentation and comments automatically
  • Supporting AI-enabled scenarios inside BC

It acts like a smart co-developer—always ready, always fast.

💻 Copilot Inside AL Development (VS Code Integration)

To leverage Copilot for AL development, developers use the GitHub Copilot extension in Visual Studio Code. This integration enables:

✔ Instant AL Code Generation

Developers can write a comment or a simple description, and Copilot generates the AL code structure automatically.

Example:

// Create a sales quote scheduler job that sends reminders

Copilot produces the full codeunit, job logic, and scheduling pattern.

✔ Faster Page & Table Extensions

Copilot instantly creates field additions, actions, triggers, and layouts without manual typing.

✔ API & Permission Set Generation

Perfect for rapid prototyping.

🤖 Using AI Inside AL Extensions

You can integrate AI into your custom extensions using Copilot-enabled system codeunits or external AI services.

Example: A simple AI-driven item description generator:

codeunit 50100 "Item AI Description"
{
    procedure Generate(ItemRec: Record Item): Text
    var
        Copilot: Codeunit "Copilot System";
    begin
        exit(
            Copilot.GenerateText(
                'Create a professional marketing description for item: ' + ItemRec.Description
            )
        );
    end;
}

This allows users to generate product descriptions instantly saving hours of manual work.

⚡ How Copilot Improves AL Developer Productivity

🟦 1. Rapid Coding

Copilot reduces 60–70% of repetitive development effort.

🟦 2. Fewer Syntax Errors

Copilot understands AL structures and suggests correct patterns.

🟦 3. Code Understanding

It can analyze and explain legacy AL code—very useful during upgrades from NAV to BC.

🟦 4. Documentation

Automatically generates comments and XML documentation.

🟦 5. Code Quality

Copilot suggests modern patterns like interfaces, single-responsibility design, and event-driven architecture.

🚨 Limitations—What Developers Should Know

Despite its strengths, Copilot is not perfect:

  • It may generate outdated syntax or patterns.
  • It cannot validate AL compiler rules.
  • It sometimes repeats code blocks unnecessarily.
  • Developers must always review and refactor generated output.

Copilot is a booster, not a replacement for AL expertise.

Copilot is not just a trend—it’s a game changer for Business Central developers. It speeds up AL development, supports learning, and enhances overall code quality. By embracing Copilot, organizations can deliver extensions faster, reduce development cost, and empower developers to focus on business logic rather than repetitive tasks.

The future of Business Central development is AI-assisted, and Copilot is leading the way.

Stay Tuned for more…

💡 Should Consultants Use Vibe Coding in Business Central?

The rise of AI-powered coding assistants has sparked a fascinating shift in the consulting world. Functional consultants, traditionally focused on business processes and requirements, are now picking up coding tools and creating technical solutions themselves. This phenomenon, often called “vibe coding,” is reshaping team dynamics and project workflows. But is this evolution beneficial, or does it create new challenges?

What is Vibe Coding?

Vibe coding refers to the practice of using AI assistants like GitHub Copilot, ChatGPT, or Claude to write code based on natural language descriptions and high-level understanding, rather than deep technical expertise. For functional consultants who understand business requirements intimately but lack extensive programming experience, these tools offer a tempting shortcut to implementation.

Why Functional Consultants Are Embracing Code ?

1. Faster Solution Delivery

Consultants can quickly generate AL code snippets, table extensions, or API wrappers using natural language prompts. What might take hours of manual coding can be drafted in minutes. This speed is particularly useful in sandbox or prototyping phases.

2. Empowered Functional Consultants

Functional consultants, who understand business processes but may lack deep AL knowledge, can experiment with configurations or customizations. This bridges the gap between functional understanding and technical execution, leading to better collaboration.

3. Lower Entry Barrier for New Developers

For junior technical consultants, Vibe Coding serves as a teaching companion. It can suggest syntax, help avoid errors, and guide them through standard Business Central development patterns.

4. Consistency and Standardization

AI-driven code suggestions can align to best practices and Microsoft guidelines (if the tool is properly trained), ensuring consistent code quality across teams.

⚠️ The Drawbacks and Risks

1. Uncontrolled Code Generation

AI tools can produce functional code that appears correct but lacks performance optimization or security validation. If used directly in production environments, this can lead to instability or compliance issues.

2. Reduced Technical Ownership

Overreliance on Vibe Coding may cause consultants to skip the learning curve of understanding Business Central’s architecture, data model, or event-driven patterns. This can erode long-term technical expertise.

3. Audit and Governance Challenges

AI-generated code might not have clear authorship or documentation. In regulated industries, this creates challenges during audits or code reviews, especially if traceability is required.

4. Data Security Concerns

If the tool transmits prompts or metadata to external servers for AI processing, it could expose sensitive business logic or schema information. This must be reviewed against company data protection policies.

👨💻 Impact on Technical Consultants

Vibe Coding doesn’t replace technical consultants — but it changes their role:

  • From coders to reviewers: Technical consultants become code reviewers and architects ensuring AI-generated outputs follow best practices.
  • From builders to enablers: They enable functional teams by setting up safe guardrails, templates, and review processes.
  • From developers to strategists: With repetitive tasks automated, technical consultants can focus on design, integration, and performance tuning.

In essence, Vibe Coding shifts technical consulting toward higher-value work, provided governance and quality checks exist.

Vibe Coding represents a powerful step toward modernizing Business Central development. It can improve efficiency, empower functional teams, and streamline solution delivery — but only when implemented with strong governance, code review, and data protection policies.

Rather than diminishing the role of technical consultants, Vibe Coding highlights their importance. They become the architects and quality guardians who ensure that AI-generated work aligns with business goals, technical standards, and long-term sustainability.

What do you think on this ?

Protecting Sensitive Data Made Easier: Introducing ‘Concealed’ Text Field Type in Business Central Wave 2 2025

Data privacy and security have become paramount concerns for businesses across all industries. With increasing regulatory requirements and growing awareness of data protection, organizations need robust yet user-friendly solutions to safeguard sensitive information. Microsoft’s Dynamics 365 Business Central Wave 2 2025 introduces a game-changing feature that addresses this challenge: the new ‘Concealed’ text field type with the innovative Mask Type property.

The Challenge: Balancing Security and Usability

Traditionally, we faced a dilemma when handling sensitive data fields. The existing ExtendedDataType = Masked property offered security by displaying field values as dots, but this approach had limitations:

  • Always hidden: Once masked, the data remained permanently concealed, even from authorized users
  • Poor user experience: Users couldn’t verify entered data, leading to potential input errors
  • Limited flexibility: No option to reveal data when legitimate access was needed

These limitations created friction between security requirements and practical usability, forcing developers to choose between protecting sensitive data and maintaining a smooth user experience.

Business Central Wave 2 2025 introduces the new MaskType enum property, revolutionizing how we handle sensitive data display. This property offers two distinct values:

MaskType Values Explained

None (Default)

  • Standard behavior where field values are fully visible in the UI
  • No masking or concealment applied
  • Suitable for non-sensitive data fields

Concealed

  • Field values are hidden by default, appearing as masked dots
  • Users can reveal the actual value through an explicit action
  • An interactive “eye” button appears next to the field for toggling visibility
  • Perfect balance between security and accessibility

Implementing the concealed field type is straightforward. Here’s how to configure it in your AL code:

field(50100; "Sensitive Data"; Text[100])
{
    Caption = 'Sensitive Information';
    MaskType = Concealed;
}

When rendered in the UI, this field will display:

  • Masked dots by default (●●●●●●●●)
  • An eye icon button for revealing/concealing the value
  • Smooth toggle animation between hidden and visible states

Supported Field Types

The MaskType = Concealed property works with:

  • Text fields: For sensitive textual information
  • Code fields: For confidential codes and identifiers
  • Decimal fields: For sensitive numeric values with decimals
  • Integer fields: For confidential whole numbers

Supported Page Types

The concealed functionality is available on:

  • Document pages: Sales orders, purchase orders, etc.
  • Card pages: Customer cards, vendor cards, item cards
  • Not supported: List page repeaters and grid controls

The introduction of the ‘Concealed’ text field type with the MaskType property in Business Central Wave 2 2025 represents a significant advancement in data protection capabilities. This feature successfully bridges the gap between security requirements and user experience, providing organizations with a flexible, user-friendly approach to protecting sensitive information.

Stay tuned for more.

Vibe Coding in AL Development for Business Central

As AL developers working with Microsoft Dynamics 365 Business Central, we often find ourselves caught between strict business requirements and the desire to write code that feels good, but with the latest Vibe Coding experience, we can see how developers interact with the platform. Instead of writing everything manually, Vibe Coding leverages AI-driven assistance, contextual suggestions, and natural language inputs to speed up solution building.

Vibe Coding isn’t just about writing code—it’s about creating a harmonious development experience that reduces cognitive load, enhances creativity, and produces more maintainable, scalable AL solutions. It combines best practices from agile development, clean code principles, and user experience design to create a holistic approach to Business Central customization.

What is Vibe Coding?

Vibe Coding is Microsoft’s new AI-assisted development experience embedded in Business Central AL development. Think of it as a “copilot for AL” — it understands your context, suggests code snippets, and helps you scaffold solutions quickly.

With Vibe Coding, you can:

  • Generate AL objects (tables, pages, code units) using natural language prompts.
  • Get inline suggestions for methods, triggers, and patterns.
  • Reduce boilerplate coding and focus on solution logic.
  • Learn AL development faster if you’re new to the ecosystem.

Getting Started

To enable Vibe Coding in AL development:

  1. Update your AL extension in Visual Studio Code to the latest version (available in VS Code Marketplace).
  2. Ensure your Business Central environment is updated to fully support Vibe Coding.
  3. Ensure Copilot features are enabled.
  4. Open your AL project and start coding — the AI suggestions will appear as ghost text or through the command palette.
Article content

Example: Creating a Table with Vibe Coding

Traditionally, you create a table object like this:

table 50100 "Customer Ledger Extension"
{
   
    fields
    {
        field(1; "Customer No."; Code[20])
        {
            DataClassification = CustomerContent;
        }

        field(2; "Ledger Balance"; Decimal)
        {
            DataClassification = CustomerContent;
        }
    }
}

With Vibe Coding, you could simply type in natural language:

“Create a table for Customer Ledger with Customer No. and Ledger Balance fields.”

And Vibe Coding will generate the AL code for you, ready to refine.

Example: Extending a Page

Say you want to extend the Customer Card page to show the new field. Instead of looking up the object ID and syntax, you could type:

“Extend Customer Card to add Ledger Balance field from Customer Ledger Extension table.”

The tool generates the boilerplate page extension code, leaving you to adjust anything you requires.

The Future of AL Development

Vibe Coding works brilliantly for proof-of-concepts and small team innovations. The sweet spot? 👉 Start with Vibe for rapid progress, then formalize as the codebase matures.

For AppSource apps and enterprise BC implementations, structured development still wins. But for exploring new features or quick client customizations? Vibe Coding can be your secret weapon.

It’s not here to replace developers — it’s here to supercharge productivity and free us to focus on innovation. 🚀

Stay tuned for more as it is still in learning phase.

Solving Barcode Printing Issues in RDLC Reports – Business Central On-Premise (v25)

When working with barcode printing in RDLC reports on Microsoft Dynamics 365 Business Central On-Premise, I recently ran into an issue that had me stumped for hours — and as it turns out, it all came down to a subtle but critical font installation step.

If you’re using Business Central and your barcodes refuse to show up in your reports (even after installing the right fonts), read on — this might just be your solution.

🚫 The Problem: Barcode Fonts Not Showing in RDLC

Here’s what I tried — the standard advice you’ll find across most forums:

  • ✅ Installed the barcode font (Code 128, Code 39, Free 3 of 9, etc.) on the service tier machine
  • ✅ Installed the same font on the user/client machine
  • ✅ Restarted the Business Central Server/NST
  • ✅ Restarted the entire machine
  • ✅ Checked that RDLC reports were using the correct font name

Still — no barcodes were rendered.

🕵️ The Hidden Detail: “Install for All Users”

After much trial and error, I stumbled across the real fix:

When installing a font on the Business Central service tier (server), you must choose “Install for all users” — not just a regular install.

Here’s why:

  • Business Central’s NST runs under a system account, not your logged-in user.
  • Fonts installed only for the current user aren’t visible to the NST process.
  • Unless the font is registered system-wide, RDLC won’t be able to use it.

Install the Barcode Font on the Server

  • Right-click the font file (e.g., Code128.ttf)
  • Choose ➡️ Install for all users

Install the Font on Client Machine (Optional but recommended)

  • This ensures previews and printed reports render properly when opened locally.

Restart the Server

  • Not just the NST service — a full restart helps Windows fully register system fonts.

It’s always the little things! A simple checkbox — “Install for all users” — was all it took to fix what seemed like a mysterious RDLC issue.

If you’re working with barcode fonts in RDLC reports on Business Central and nothing seems to work, double-check your font installation method — this could save you hours of frustration.

Hope this will help!!!

Introducing ExcelLayoutMultipleDataSheets in Business Central 2025 Wave 1

With the release of Business Central 2025 Wave 1, business central continues to enhance developer and user experience in reporting and data analysis. One such powerful addition is the new property: ExcelLayoutMultipleDataSheets. This feature addresses a long-standing limitation in Excel export scenarios—allowing multiple datasets to be exported into separate sheets within a single Excel workbook.

What is ExcelLayoutMultipleDataSheets?

The ExcelLayoutMultipleDataSheets property is a new setting introduced for report objects that use Excel layouts. It enables developers to bind multiple data items or datasets to different worksheets in an Excel layout file (.xlsx), making reports more organized and structured when exported.

🧩 Structured Reports
Separate sheets for different datasets make it easier for business users to navigate complex reports—such as Sales Orders on one sheet, Customer Info on another, and Totals on a summary sheet.

🛠️ Developer Control
You can name your data items and match them to sheet names in your Excel layout. This gives you more granular control and reduces the need for workarounds.

How to Use ExcelLayoutMultipleDataSheets

report 50100 MyMultiSheetReport
{
    UsageCategory = ReportsAndAnalysis;
    ApplicationArea = All;
    DefaultRenderingLayout = MyExcelLayout;
    ExcelLayoutMultipleDataSheets = false; // Global setting is to use a single sheet

    dataset
    {
        dataitem(Customer; Customer)
        {
            column(CustomerNo; "No.") { }
            column(CustomerName; Name) { }
        }
        dataitem(Vendor; Vendor)
        {
            column(VendorNo; "No.") { }
            column(VendorName; Name) { }
        }
    }

    rendering
    {
        layout(MyExcelLayout)
        {
            Type = Excel;
            ExcelLayoutMultipleDataSheets = true; // Override for this specific layout
        }
    }
}

In this example, even though the global ExcelLayoutMultipleDataSheets property for the report is set to false, the MyExcelLayout will render the output with two separate worksheets:

  • Data_Customer containing the customer data.
  • Data_Vendor containing the vendor data.

If the ExcelLayoutMultipleDataSheets property within the MyExcelLayout definition was set to false (or not specified), both datasets would be combined into a single “Data” sheet in the Excel output.

The enhancement of the ExcelLayoutMultipleDataSheets property in Business Central Wave 1 2025 offers developers greater flexibility and control over Excel report layouts. By enabling the creation of multi-sheet Excel files at the layout level, you can deliver more user-friendly and better-organized reports, ultimately empowering your users to gain deeper insights from their Business Central data.

Stay tuned for more ….

Optimizing Business Central Reports with the DataAccessIntent Property

When developing reports in Microsoft Dynamics 365 Business Central, performance and scalability are crucial—especially in cloud environments where system efficiency impacts everything from responsiveness to cost. One often-overlooked feature that can significantly enhance report performance is the DataAccessIntent property.

What Is DataAccessIntent?

The DataAccessIntent property is available on report objects in AL. It specifies how a report should access the database—whether it’s read-only or read-write.

The property supports two values:

  • DataAccessIntent = ReadOnly
  • DataAccessIntent = ReadWrite

ReadOnly

When you set DataAccessIntent = ReadOnly, you are explicitly telling the platform that your report only needs to read data from the database and will not perform any write operations.

Why is this important?

  • Better Performance: In Business Central SaaS, reports marked as ReadOnly can run on read-only replicas of the database. This reduces the load on the primary (read-write) database and enhances scalability.
  • Improved Report Execution Time: Since queries are routed to optimized replicas, report rendering can be faster and more efficient.

ReadWrite

If your report needs to modify data during execution—a rare scenario—you should use DataAccessIntent = ReadWrite. This forces the report to run on the primary database.

However, you should avoid using ReadWrite unless absolutely necessary because:

  • It eliminates the benefit of using read replicas.
  • It may degrade performance, especially under high concurrency.

When to Use Each

ScenarioUse ReadOnly?Use ReadWrite?
Standard data listing/reporting✅❌
Reports that update records❌✅
Diagnostic or audit reports✅❌

How to Set DataAccessIntent in AL

report 50100 "Customer Balance Report"
{
    DataAccessIntent = ReadOnly;

    dataset
    {
        dataitem(Customer; Customer)
        {
            column(Name; Name) { }
            column(Balance; "Balance (LCY)") { }
        }
    }

    layout
    {
        // Define RDLC or Word layout
    }
}

By default, if you don’t specify the property, it behaves as ReadWrite. So it’s a good practice to explicitly set it to ReadOnly when applicable.

Important Considerations

  • The DataAccessIntent property is only a hint to the Business Central server. The server may not always be able to use a read-only replica, even if the property is set to ReadOnly.
  • If a report with DataAccessIntent set to ReadOnly attempts to modify data, a runtime error will occur.
  • The DataAccessIntent property can be overridden by the user through the “Database Access Intent List” page in Business Central.

In short: if your report doesn’t write data, use DataAccessIntent = ReadOnly. It’s an easy win for performance and best practice compliance.

Stay tuned for more….

Boosting Performance in Business Central with SETLOADFIELDS

When building customizations or integrations in Microsoft Dynamics 365 Business Central, performance is often a key concern—especially when working with large datasets. One powerful tool for improving performance is the SETLOADFIELDS method on record variables.

🚀 What is SETLOADFIELDS?

In Business Central, when you retrieve a record (using FIND, GET, NEXT, etc.), all fields of the record are loaded from the database by default. This includes fields you might never use, such as FlowFields (which are calculated on the fly). This can lead to unnecessary memory usage and slower data retrieval.

SETLOADFIELDS tells the system which fields to load, so it skips the rest. This can dramatically improve performance, particularly when:

  • You’re looping through large datasets
  • You’re only using a few fields per record
  • Your table includes FlowFields or BLOBs

📘 Syntax

Rec.SETLOADFIELDS(Field1, Field2, ...);

You place this line before reading the records. This tells the AL runtime engine to load only the specified fields when the records are retrieved.

Let’s say you need to loop through all items and check their No. and Inventory:

Item.SETLOADFIELDS("No.", Inventory);
if Item.FINDFIRST then
  repeat
    if Item.Inventory > 0 then
      // do something
  until Item.NEXT = 0;

  1. Use SETLOADFIELDS only when needed – Overusing it without understanding the data flow may result in missing fields or unexpected behavior.
  2. Calling CALCFIELDS still works – You can still explicitly calculate FlowFields after using SETLOADFIELDS.
  3. Resets on modification – If you call MODIFY, INSERT, or VALIDATE, the load fields context is reset. Use SETLOADFIELDS again if necessary.
  4. BLOB and FlowFields – Avoid loading BLOBs and FlowFields unless absolutely necessary. SETLOADFIELDS helps you skip them efficiently.

👨‍💻 Summary

FeatureWithout SETLOADFIELDSWith SETLOADFIELDS
Data LoadedAll fieldsOnly specified fields
Memory UsageHighLower
SpeedSlowerFaster

By leveraging SETLOADFIELDS, developers can significantly optimize the performance of their AL code in Business Central. It’s a small addition that can make a big difference in speed and scalability.

Avoid it when doing full record operations like MODIFY, unless you’re confident about which fields are required.

Stay Tuned for more…

Understanding GETRANGEMIN() and GETRANGEMAX() in Business Central

When working with filters and record ranges in AL , two handy functions often come into play: GETRANGEMIN() and GETRANGEMAX(). These functions help you programmatically access the lower and upper bounds of a filter applied to a field in a record. This can be especially useful for creating reports, processing data, or passing filters between records.

What are GETRANGEMIN() and GETRANGEMAX()?

These two functions are part of the Record data type and help retrieve the range boundaries for a specific field filter.

  • GETRANGEMIN(Field): Returns the lowest value in the filter range for the specified field.
  • GETRANGEMAX(Field): Returns the highest value in the filter range for the specified field.

If there is no filter set for the field, both functions return blank.

SalesHeader.SETFILTER("No.", '1000..2000');

MinNo := SalesHeader.GETRANGEMIN("No."); // Returns '1000'
MaxNo := SalesHeader.GETRANGEMAX("No."); // Returns '2000'

Use Cases

1. Transferring Filter Ranges

If you’re applying a filter on one table and want to use the same range on another:

Customer.SETFILTER("No.", 'C00010..C00020');
SalesHeader.SETRANGE("Sell-to Customer No.", Customer.GETRANGEMIN("No."), Customer.GETRANGEMAX("No."));

2. Generating Custom Reports

SalesHeader.SETFILTER("Posting Date", '2024-01-01..2024-01-31');

StartDate := SalesHeader.GETRANGEMIN("Posting Date");
EndDate := SalesHeader.GETRANGEMAX("Posting Date");

MESSAGE('Report for: %1 to %2', StartDate, EndDate);

3. Validating Filtered Data

IF (SalesHeader.GETRANGEMIN("Posting Date") < AllowedStartDate) OR
   (SalesHeader.GETRANGEMAX("Posting Date") > AllowedEndDate) THEN
    ERROR('Filter range is outside allowed period.');

The GETRANGEMIN() and GETRANGEMAX() functions are powerful tools when working with dynamic filters in AL. They enable developers to write cleaner, more adaptable code by directly accessing the boundaries of filter conditions.

Stay Tuned for more updates.

Boosting Performance in Business Central with SetAutoCalcFields

In today’s fast-paced business environments, performance optimization is not a luxury — it’s a necessity. Whether you’re building custom reports, extending pages, or writing integration APIs in Microsoft Dynamics 365 Business Central, slow operations can frustrate users and strain resources.

One simple but powerful technique to improve performance is using the SetAutoCalcFields method.

Why FlowFields Matter for Performance

In Business Central, FlowFields are virtual fields calculated on the fly, not stored physically in the database. Examples include:

  • Inventory on Item
  • Balance on Customer

When you retrieve a record, FlowFields are not calculated automatically unless you explicitly call CalcFields().

Manually calculating FlowFields for every record during loops, leading to multiple SQL queries — one for each record — causing heavy load and slower performance.

SetAutoCalcFields solves this by batch-calculating FlowFields along with the record fetch.
Instead of running one query per record, it combines the calculation in a single optimized query.

Imagine fetching 1,000 customers and displaying their balances without SetAutoCalcfields:

CustomerRec.FindSet();
repeat
    CustomerRec.CalcFields(CustomerRec.Balance); // Triggers a DB call every time!
    DisplayBalance(CustomerRec."No.", CustomerRec.Balance);
until CustomerRec.Next() = 0;

Result:
  • 1 SQL query to get Customers
  • + 1,000 SQL queries for Balances

With SetAutoCalcFields:

CustomerRec.SetAutoCalcFields(CustomerRec.Balance);
CustomerRec.FindSet();
repeat
    DisplayBalance(CustomerRec."No.", CustomerRec.Balance);
until CustomerRec.Next() = 0;

Result:
  • 1 SQL query to get Customers and Balances together

Benefits of Using SetAutoCalcFields

  • Improved Page Load Times: By deferring calculations, pages with numerous records and calculated fields will load significantly faster.
  • Faster Report Generation: Reports that rely on calculated fields will be generated more quickly as the calculations are performed only when the field’s value is actually needed for display or processing.
  • Reduced Database Load: Fewer automatic calculations translate to fewer database queries, reducing the overall load on your Business Central database.
  • Enhanced User Experience: Snappier performance leads to a more responsive and enjoyable user experience.

Best Practices for Performance Gains

To maximize the benefits of SetAutoCalcFields:

  • Only specify necessary FlowFields:
    Don’t auto-calculate every FlowField — focus on what your process needs.
  • Use it before data retrieval:
    Call SetAutoCalcFields before FindSet(), FindFirst(), or FindLast()
  • Avoid unnecessary recalculations:
    Once FlowFields are set to auto-calculate, do not manually call CalcFields() again for the same fields.
  • Monitor heavy FlowFields:
    Some FlowFields (e.g., Inventory) involve complex sums across tables — only auto-calculate when really needed.
  • Profile your code:
    Use Performance Profiler to measure improvements.

Using SetAutoCalcFields properly can lead to dramatic performance improvements in Business Central.
By reducing SQL traffic, simplifying code, and batch-fetching FlowFields intelligently, you can create faster, cleaner, and more scalable applications.

A small change in your coding habits can create a big impact for your users.

Hope this will help..