Integration, Not Customisation: Business Central in the UAE
Most Business Central customisation requests are integration work. See where UAE payment, e-commerce and messaging integrations break, and how to fix it.

AI-generated header image for: Integration, Not Customisation: Business Central in the UAE
Most Business Central "customisation" requests in the UAE start with a workflow complaint. The real requirement is usually integration. That distinction is not semantic. It decides whether you add code to a screen or design a controlled flow across payment providers, e-commerce, messaging, banking, and Business Central itself. This analysis separates the direct intermediary from the integration interface, then treats payment design as a scoping decision before a technical one. From there, the post explains why integrations break at commercial boundaries rather than API calls, how matching rules, exception queues, and a named owner turn a settlement screen into an operational control, and why idempotency and retry logic must design duplicates out of the flow. It also covers e-commerce and messaging integrations, upgrade-safe design, and a scoping checklist before you commission the next ERP integration. The goal: turn integration work into a managed path, not an annual rebuild.
Why Most ERP Integration Requests Arrive Labelled as Customisation
Most requests arriving as "we need a customisation" are three things wearing one label. Some are new business rules; some are gaps standard configuration already closes. The third, and most common, is a connection to an outside system never designed to sit inside Business Central.
An integration moves data between Business Central and another system while leaving the core application and its update path intact; a customisation changes the core itself. The distinction matters because code reaching into standard tables, posting routines or base events must survive every cumulative update, so its cost recurs annually instead of once. Keeping that logic outside the core carries less recurring burden.
Payments, e-commerce and messaging fall into the integration category because a second system already owns part of the truth: a settlement record, an order state, a message delivery log. The scoping question is which system owns this record, not which fields to add.
The difficulty is rarely the API call. It is what happens when two systems disagree about money, orders or messages. Treating that disagreement as a customisation problem hides the real work.
The Direct Intermediary and the Integration Interface Are Not the Same Job
Call the direct intermediary whatever sits inside the money, order or message path: a payment service provider or licensed entity that holds funds, moves instructions or settles merchants. Its behaviour, pricing and obligations are contractual and often regulated.
The integration interface is everything inside your landscape that translates between Business Central and that party: API calls, webhooks, mapping tables, queues, retry handlers and the reconciliation views finance uses.
Treat this split as our working model for scoping, not an industry standard or regulatory classification. Its value is keeping two conversations apart.
The confusion is expensive. Teams try to solve licence, payout-timing or data-residency questions with development hours; others try to solve a field-mapping problem by changing providers. In our experience, both often lead to rebuilding the same integration within a year.
Apply a three-question test per integration: who holds the money, who holds the authoritative record, and who is accountable when the two disagree? Unclear answers mean no amount of clean code will hold.
In multi-country GCC landscapes, the intermediary differs by market while the interface layer should stay consistent across Business Central entities. That consistency is where integration and API design effort belongs, while local customisation is a separate conversation. This is the pattern Index of Solutions applies on Business Central, LS Central and Power Platform integration projects across the Middle East, including Lebanon and the KSA market.
In the UAE, Payment Design Is a Scoping Decision Before a Technical One
Within the RPSCS framework introduced above, each assessed activity carries its own obligations: payment accounts, acquiring and aggregation, transfers, payment initiation and account information services, and card scheme activities where applicable. Redirecting funds or splitting an acquirer arrangement changes provider obligations and is a scoping decision, not a sprint item. Card tokenisation is a security technique, not a regulated payment token. The CBUAE Payment Token Services Regulation, C 2/2024, in force since 31 August 2024, separately covers issuance, conversion, and custody and transfer. Vendor language conflates the two. Routing money through a new path can shift the regulatory perimeter, so payment flow design belongs with legal counsel reviewing the full CBUAE Rulebook. Run integration and legal review as parallel workstreams with separate owners. This framework summary is attributed; several CBUAE pages returned navigation only, so this states no specific obligations. Verify against the Payment Token Services Regulation. Payment scoping most commonly arises during a wider platform move, when teams are already re-examining how money flows through the business.
ERP Integrations Break at Commercial Boundaries, Not at API Calls
None of the following is a measured rate. These are recognisable patterns from integration design practice, recurring because two systems define "done" differently.
Unmatched payments. Settlement arrives with a reference matching no invoice or order, so the amount sits in a suspense account until someone chases the provider. The API call succeeded; the commercial event did not.
Duplicate orders. A webhook fires twice, or a retry completes after the caller timed out, and the same order posts twice. Finance unwinds credit notes, stock counts distort, revenue is restated by hand.
Silent retries. A queue retries a rejected payment instruction without alerting anyone. The failure surfaces weeks later in a bank reconciliation, not on the day it happened. Nobody received an error, which is the problem.
Sequence mismatch. E-commerce and messaging events arrive in a different order from payment events, so Business Central can briefly see a paid order before the order record, or a cancellation after fulfilment released stock.
These are not exotic edge cases at the API layer. They follow from two systems with different clocks, currencies, cut-off times and definitions of done. That is a design problem at the commercial boundary, and it is solvable there.
The Settlement Screen: Matching Rules, Exception Queues and a Named Owner
The remedy is operational. A settlement screen shows provider reference, internal document number, gross amount, fees, net amount, currency, value date, current status and age in the queue. If finance cannot explain the unmatched balance line by line from one screen, the integration is unfinished.
Matching rules should be written and applied in order of confidence: exact reference match first, then amount plus value date plus customer, then manual review. Never auto-match on amount alone; equal amounts on the same day are common at retail and trading volumes.
Exceptions belong in a persistent queue, not an email inbox. Assign one named owner per integration with escalation thresholds measured in hours. Ownership turns silent failure into a visible task with a deadline.
Add a daily close routine: the unmatched balance is explainable by end of day, and the screen records who cleared each item and how. That audit trail supports month-end and shows whether a recurring mismatch is a mapping bug or a provider cut-off issue, feeding smarter bank reconciliation.
This screen, not the connection, is often an integration project's highest-value deliverable: it converts invisible commercial risk into scheduled work.
Idempotency and Retry Logic: Designing Duplicates Out of the Flow
A visible queue catches what arrived. It does not stop a second copy arriving.
Idempotency is engineering practice, not a vendor feature: every message carries a unique key generated at the source, and the receiver stores processed keys, returning the original result rather than creating a second document. A new key means a new operation, so persist the key across retries.
Retry only transport failures, timeouts and transient errors; never a business rejection such as a declined payment, where the answer will not change. Use exponential backoff with a cap so a struggling provider is not flooded.
After a defined number of attempts, the message moves to a dead-letter queue a human can see, with enough payload to replay it safely once the fault is fixed. A retry loop with no exit is just a delay.
Order status updates with sequence numbers or timestamps, kept monotonic, so an older message cannot overwrite a newer one and reopen a closed payment or a cancelled order.
None of this comes from the regulatory sources reviewed here; treat it as design practice and verify against current provider documentation before building.
In Business Central, put this logic in an integration layer outside the core, calling documented APIs and subscribing to published events; a cumulative update then changes the interface, not the rule book.
E-commerce and Messaging Integrations: Same Rules, Different Clocks
The same idempotency discipline applies to e-commerce and messaging, but the clocks differ. In e-commerce, orders often arrive before payment confirmation and cancellations after fulfilment, so stock must reserve and release correctly. State which system owns order state and which owns payment state before connecting anything; a warehouse management capability built into Business Central removes one boundary, but not this one.
Messaging events (delivery notifications, payment links, template messages) only reconcile when tied to a Business Central document number, not a phone number alone.
Both domains face the same three questions asked of payments: who owns the record, what happens when the same event is delivered twice, and where the exception surfaces when systems disagree. They differ in detail, not principle.
The framing differs honestly: UAE payments carry a regulatory layer that shapes scoping, while e-commerce and messaging are driven by commercial and operational choices such as cut-off times, stock ownership and customer-response obligations. Connector behaviour varies by provider, version and tenant configuration and changes without notice, so verify any flow against current provider documentation before committing it to a plan.
Does Upgrade-Safe Integration Really Avoid the Annual Rebuild?
Across all three domains, treat this as a hypothesis rather than a proven outcome. Teams that push external logic into an integration layer and keep core objects clean should meet less rework at each Business Central cumulative update. No data in this research supports a percentage or a guarantee.
The mechanism is plausible: fewer modified standard tables, fewer replaced posting routines and a smaller base event footprint mean fewer collisions when Microsoft changes APIs, events or page behaviour. The Upgrade Problem Nobody Talks About describes the same pressure from the maintenance side.
The counter-case deserves equal weight. A heavily modified posting routine can run unchanged for years. When it breaks, the cost is concentrated, unbudgeted and urgent, often landing when finance cannot tolerate downtime.
Test it in your own landscape: count modified core objects, count custom event subscribers, track hours spent on integration fixes at each update, and compare that with the cost of maintaining the integration layer.
The benefit is a managed development path versus an annual rebuild, earned through design choices about where logic lives, not by choosing a particular provider alone.
A Scoping Checklist Before You Commission the Next ERP Integration
Upgrade safety is shaped before development starts. Use this checklist when commissioning the next ERP integration.
Write the direct intermediary and the integration interface as separate items, and confirm who holds the money, the order state and the message record per flow before a field is mapped.
Commission the settlement screen and its named exception-queue owner in the statement of work.
Specify the four-line idempotency contract per message (key, retry policy, dead-letter destination, ordering rule) in the technical specification.
Keep legal review of payment flows against the full CBUAE text on a separate track, with its own owner and sign-off, running parallel to technical design.
Define done for upgrade safety: core objects touched, event subscribers added, and a written plan for the next cumulative update before close.
Assign one accountable person per integration and put the settlement screen into their daily routine, so unmatched items age visibly instead of accumulating quietly.
This checklist turns integration work into a managed path.
Conclusion: Turning Integration Work into a Managed Path
The checklist is only useful if it changes the next conversation. When a "we need customisation" request arrives, ask which system owns the record. If the answer sits outside Business Central, it is an ERP integration; if it changes how the core posts, behaves or reports, it is a change to the core. Settle that before estimation.
The design commitments follow from there. The design commitments -- settlement screen with a named owner, idempotency contract, and logic kept outside core objects -- belong in scope before API work begins. UAE payment flows additionally require a parallel legal-review track, as set out above.
Then measure. Count core objects touched and hours spent on fixes at every release. That is how a managed development path replaces an annual rebuild.
