New: Odoo and Dynamics 365 cost calculators.Estimate your costs

ERP Architecture Explained

ERP architecture for SMEs: three tiers, shared database, modular vs composable, multi-tenant tenancy, and suite vs best-of-breed trade-offs.

Both platformsERP Fundamentals14 min readUpdated 21 sources

Key takeaways

  • ERP architecture refers to the technical structure and design principles that govern how an ERP system organizes its components — the database, the application logic, the user interface, and the integration layer — and how those components talk to each other.
  • If you strip an ERP down to its single most important architectural decision, it is the shared database.
  • Almost every modern ERP — from SAP S/4HANA to Microsoft Dynamics 365 Business Central to Odoo — is built on a three-tier (multitier) architecture that separates concerns into distinct layers.
  • The application layer is the part most buyers never see but most feel.

What ERP architecture actually means

ERP architecture refers to the technical structure and design principles that govern how an ERP system organizes its components — the database, the application logic, the user interface, and the integration layer — and how those components talk to each other. It is the answer to the question 'how is this thing built under the hood?', and it determines the things buyers care about most later: how hard it is to customise, how safely it upgrades, how well it scales, and how much it locks you in.

This is a different question from 'what is an ERP'. A definitional guide tells you that an ERP unifies finance, operations, inventory, and sales into one connected system. An architecture guide tells you how that unification is actually engineered — what sits where, what shares what, and where the seams are. Two ERPs can have identical feature lists and radically different architectures, and the architecture is what predicts whether your implementation will be quick and contained or expensive and entangling.

Think of it like a building. The floor plan (features) tells you which rooms exist. The architecture tells you whether the walls are load-bearing, whether the plumbing is shared or per-unit, and whether you can knock a wall down without bringing the roof with it. When you are choosing an ERP you are not just buying rooms — you are buying a structure you will live inside for a decade.

The shared database: the trait that makes an ERP an ERP

If you strip an ERP down to its single most important architectural decision, it is the shared database. Every module — finance, inventory, sales, purchasing, HR, manufacturing — reads from and writes to one common data store, structured by one shared data model. When a sales order is confirmed, inventory decrements in the same database; when inventory moves, the general ledger posts in the same database. There is no nightly batch reconciliation between systems, because there is only one system at the data layer.

This is what separates a true ERP from a collection of integrated point tools. A standalone CRM bolted to a standalone inventory tool with a sync job is not the same architecture: the two systems each own their own database, and the sync is a fragile, latency-prone bridge between two sources of truth. In a shared-database architecture, there is no bridge because there is no gap. Oracle's definition of ERP leans on exactly this point: the defining trait is an integrated shared data model rather than disconnected applications.

The practical payoff is data integrity. Because every transaction writes to one schema with defined relationships and (usually) ACID transaction guarantees, you cannot get the finance total and the inventory total to disagree — they are computed from the same rows. Reporting becomes real-time rather than a weekly export-and-reconcile exercise. And master data — customers, suppliers, products, chart of accounts — exists once, not duplicated and drifted across three databases.

The shared database is also the root of the monolith-versus-composable tension that runs through the rest of this guide. As soon as you let different capabilities own different databases and talk over APIs instead of sharing tables, you gain flexibility but you reintroduce the integration problem the shared database was invented to solve. Every architectural choice below is, at bottom, a stance on how much to share.

The classic three-tier architecture

Almost every modern ERP — from SAP S/4HANA to Microsoft Dynamics 365 Business Central to Odoo — is built on a three-tier (multitier) architecture that separates concerns into distinct layers. ERPEDIA's architecture reference is blunt about why this pattern dominates: each layer can be scaled or updated independently, which is what makes a large system maintainable at all.

The first tier is the presentation layer — the web client, mobile apps, dashboards, and any external UI that users actually touch. In a modern cloud ERP this is HTML5, JavaScript, and CSS, often delivered through a component framework (Odoo ships its own OWL web framework from version 15 onward, for example). The presentation layer holds no business truth; it only renders state and captures input.

The second tier is the application layer — the business-logic engine. This is where validations, workflows, posting routines, approval rules, and the reporting engine live. It is written in the platform's native language: Python in Odoo, C#/.NET in Business Central's server component, ABAP in SAP. The application layer enforces the rules that keep the shared database consistent and is the tier developers spend most of their time in.

The third tier is the database layer — the relational repository that holds both the object definitions (the schema) and the business data (the transactions). Nearly all ERPs rely on a relational database with ACID transaction support; SAP S/4HANA is unusual in using an in-memory columnar database (SAP HANA) so that transactions and analytics run against the same data without a separate warehouse. Separating these three tiers is what lets a vendor scale the database independently of the app servers, update the UI without touching the ledger, and expose the same logic to a mobile client and a web service simultaneously.

Inside the application-logic layer: the engine and the ORM

The application layer is the part most buyers never see but most feel. It is where a 'confirm sales order' click becomes a chain of behind-the-scenes actions: check credit limit, reserve stock, generate a delivery, post the revenue, update the customer balance, fire an event to the warehouse. How that logic is organised is a major architectural differentiator between platforms.

Object-Relational Mapping (ORM) is the dominant pattern in modern modular ERPs. An ORM lets developers declare a business object — an invoice, a product, an employee — as a class in code, and automatically maps it to database tables, generates CRUD operations, handles relationships, and enforces constraints. Odoo's framework is built around its ORM: Python business-object classes define fields that are automatically persisted to PostgreSQL, and the ORM handles the queries, joins, and access rights. Business Central takes a related but distinct approach with its AL language and strongly-typed application objects (tables, pages, codeunits), orchestrated by a .NET-based server component that uses Windows Communication Framework to mediate between clients and the database.

The architectural consequence of an ORM-driven app layer is that customisation becomes safer and more uniform. Instead of hand-writing SQL against shared tables (which is what corrupts the data layer in legacy systems), developers extend typed models through the framework, and the framework enforces consistency. This is the foundation that makes modular, upgrade-safe extension models possible — and it is why a modern ERP's app layer matters more than its raw feature count.

Modular apps on a shared data model

A modern ERP is built from modules — functional blocks you switch on as the business needs them. The critical architectural point, and one buyers frequently misunderstand, is that a module is not a separate product. It is a capability that plugs into the shared database and the application layer, reusing the same customers, products, and ledger rather than standing up its own.

Odoo is the clearest illustration. Its own architecture documentation states that 'everything in Odoo starts and ends with modules': both server and client extensions are packaged as modules optionally loaded into a database, and a module is a collection of functions and data targeting a single purpose. A module can add new business logic (say, country-specific accounting rules) or alter and extend existing logic — but because every module shares the same ORM and the same PostgreSQL schema, an invoice created in one module is immediately visible and consistent with inventory, sales, and finance modules. Business Central mirrors this with its extension model: AL extensions hook into the application's events (such as OnBefore or OnAfter posting) and ship as either AppSource extensions (multi-tenant, Microsoft-validated) or per-tenant extensions (private to one environment).

This is what separates 'modular ERP' from 'best-of-breed point tools'. True modular ERP means independent functional modules on a shared data model, with consistent governance and replaceable components. A collection of SaaS apps stitched together with sync jobs is not modular ERP — it is best-of-breed, and it pays for its flexibility in integration overhead. The distinction matters because vendors market both approaches with the word 'modular', and the architecture underneath is fundamentally different.

The integration layer: where the ERP meets everything else

No ERP lives alone. Modern ERPs expose a defined integration layer — APIs, web services, and event hooks — that lets external systems read from and write to the core without touching its tables directly. In Business Central this layer is surfaced as SOAP and OData web services that expose pages, codeunits, and queries; Odoo exposes XML-RPC and JSON-RPC endpoints plus its own controller framework; S/4HANA exposes OData services and SAP's broader integration tooling; NetSuite exposes SuiteTalk REST and SOAP plus SuiteQL for query access, subject to multi-tenant concurrency limits.

Architecturally, the integration layer sits as a controlled gateway between the shared database and the outside world. It is the seam that lets your e-commerce store check stock in real time, your CRM push a won deal into an order, or your bank feed flow into the ledger — all without giving those systems direct database access. Treating integration as a tier (with its own security, rate-limiting, and transformation rules) is what keeps the core database clean and auditable.

How you design flows across that seam is its own discipline, and it is where most integration cost hides. Point-to-point connections work for one or two edge systems, then collapse into what practitioners call integration spaghetti as the count grows. A hub-and-spoke iPaaS centralises mapping and monitoring so each new connector is a configuration, not a custom project. Event-driven architecture goes further: the ERP publishes domain events (order confirmed, inventory adjusted, invoice posted) and subscribers react asynchronously, which is the pattern that keeps commerce, WMS, and AI layers loosely coupled without polling the core for every change.

API-first commerce and edge patterns sit on top of that same seam. Headless storefronts, mobile warehouse apps, and partner portals should call documented APIs or consume events rather than embedding business rules outside the ERP. When the edge invents its own stock or pricing truth, you have rebuilt the multi-database problem the shared database was meant to eliminate. The same ERP can be wired well or catastrophically depending on the integration pattern you layer on top of it — which is why integration design belongs in selection, not as a post-go-live afterthought.

Monolithic vs modular vs composable ERP

Every ERP on the market sits somewhere on a spectrum from tightly-coupled monolith to fully composable, and where it sits is the single biggest architectural predictor of your total cost, upgrade safety, and flexibility. The three positions are not marketing labels — they describe genuinely different structures under the hood.

A monolithic ERP is a single, tightly integrated program in which all modules share one codebase and one database, and changes typically require whole-system testing. This is the architecture of classic on-premise suites like SAP R/3: extremely deep integration and consistency, but slow to change and expensive to upgrade because everything moves together. A modular ERP keeps the shared database but breaks the application layer into independent modules that communicate through the framework's APIs, so you can upgrade or extend one module without redeploying the whole system — this is the architecture most modern cloud ERPs (Odoo, Business Central, Acumatica) actually ship. A composable ERP goes further: it assembles the ERP from interchangeable, API-connected components around a lean core, accepting more interfaces in exchange for the freedom to swap in best-of-breed capabilities.

The composable direction is not a fringe idea — it is where Gartner has been pushing the market for a decade, first under the term 'postmodern ERP' (a federated mix of core and edge applications) and now as 'composable ERP', an architecture where enterprise applications are assembled from modular building blocks connected through APIs. Gartner's Packaged Business Capability (PBC) concept formalises the building block: a PBC is an encapsulated software component representing a well-defined business capability, technically a bounded collection of a data schema, services, APIs, and event channels. The MACH Alliance has pushed the same idea (Microservices, API-first, Cloud-native, Headless), and composable architecture is now a mandatory inclusion criterion in many analyst evaluations. Midsize CIOs are increasingly told to keep a 'good enough' core and compose differentiation at the edge rather than chase a perfect all-in-one suite.

The honest caveat: composable is not universally better. It trades the simplicity and guaranteed consistency of a shared-database monolith for flexibility and reduced lock-in — and it reintroduces the integration burden that the shared database was invented to eliminate. Microservices-style ERP decompositions are an extreme form of that trade: each service owning its own database can scale and fail independently, but you inherit distributed-transaction complexity, eventual consistency, API freeze, and observability cost that most SMEs cannot staff. Practitioners who have lived through premature microservices often land on a modular monolith — clear module boundaries in one deployable system — as the practical middle ground. For most SMEs, a modular cloud ERP on a shared data model hits the sweet spot: enough modularity to extend and upgrade safely, enough integration to avoid running a permanent integration project alongside the business.

Monolithic vs modular vs composable ERP architecture — the trade-off buyers are actually choosing between.
DimensionMonolithic suiteModular (shared-DB) ERPComposable ERP
Data modelOne codebase, one databaseShared database, modular app layerLean core + best-of-breed components
How components talkDirect in-process callsFramework APIs + ORMAPIs and events across components
CustomisationDeep but risky, whole-system testingConfigurable, extension-safeReplace any component independently
Upgrade safetyLow — everything moves togetherHigh — modules upgrade separatelyHighest — swap components at will
Integration burdenLowest (everything shares tables)Low (internal), controlled externalHighest (more interfaces to govern)
Best fitComplex, process-heavy enterprisesMost SMEsLarger firms with mature integration teams

How five real ERPs are actually architected

The architecture concepts above are easier to grasp against real platforms. The five systems SMEs and multi-entity groups most often shortlist — Odoo, Microsoft Dynamics 365 Business Central, Dynamics 365 Finance & Operations, Oracle NetSuite, and SAP S/4HANA — all use a multi-tier structure, but they implement the tiers very differently, and those differences map directly to how each is bought, customised, and run.

Odoo is a Python-and-PostgreSQL multitier system. Its official documentation states it follows a multitier architecture in which the presentation tier is HTML5, JavaScript, and CSS (driven by its in-house OWL framework), the logic tier is exclusively Python, and the data tier supports PostgreSQL as its RDBMS. Everything is a module loaded into a database, and the ORM maps Python business objects to PostgreSQL tables. Because the entire stack is open source and the ORM is the primary extension surface, Odoo is unusually easy to customise deeply — which is an architectural strength and a governance risk in equal measure. Multi-company is typically one database with company-scoped records rather than separate tenant databases per legal entity.

Microsoft Dynamics 365 Business Central is a .NET-based, cloud-first, multi-tenant SaaS. Microsoft's deployment documentation describes its three core components: a SQL database (SQL Server, Azure SQL Managed Instance, or Azure SQL Database) holding application object definitions and business data; a .NET-based Business Central Server that uses Windows Communication Framework to handle communication between clients and the database and controls authentication, scheduling, and reporting; and an IIS web server exposing the web and mobile clients. Its defining architectural trick is multitenancy: in a multitenant deployment, the application code and the business data are separated into different databases, so one application database serves many tenants while each tenant's data stays isolated in its own database. Customisation happens through AL language extensions, deployed as either multi-tenant AppSource extensions or single-tenant private extensions. Companies and intercompany flows live inside a tenant database rather than as separate ERPs per legal entity.

Dynamics 365 Finance & Operations (finance, supply chain, and commerce apps in the enterprise Dynamics 365 family) is a different architectural beast from Business Central. It is a heavier, scale-oriented ERP stack with its own database and application services, designed for complex manufacturing, multi-legal-entity finance, and high-volume supply chain. When organisations also run Dynamics customer-engagement apps (Sales, Customer Service), Microsoft's dual-write infrastructure provides near-real-time, bidirectional sync between finance and operations apps and Microsoft Dataverse so CRM and ERP share master and transactional data without a separate custom bus. Architecturally that means F&O is not a single shared-database product with CRM — it is a dual-system design with a first-party integration fabric, and solution architects must design for dual-write constraints, environment pairing, and latency as first-class concerns.

Oracle NetSuite is a true multi-tenant SaaS: every customer runs the same application instance and codebase on Oracle Cloud Infrastructure, with customisations layered on top of the shared core. Oracle packages that extensibility as SuiteCloud — SuiteScript (JavaScript) for application logic, SuiteFlow for workflows, SuiteTalk REST/SOAP for integration, and SuiteQL for query access. Because all tenants share the upgrade train, customisations migrate with platform releases and you do not choose the upgrade window. The shared multi-tenant model is NetSuite's architectural identity: strong consistency of the product surface across customers, automatic updates, and rate/concurrency limits on SuiteTalk that high-volume integrations must design around rather than ignore.

SAP S/4HANA is a three-tier system with a decisive architectural simplification at the database layer. For decades SAP ran on a classic three-tier model where the choice of database did not matter; S/4HANA collapses the application and database workloads onto SAP HANA, an in-memory columnar database that supports both row and column tables in the same database. The famous 'code pushdown' moves data-intensive logic out of the ABAP application layer and into the HANA database itself, so that transactions and analytics run against one set of data without a separate analytical warehouse. The result is real-time reporting on live transactional data, at the cost of being bound to a single database platform. Public-cloud and private editions differ in tenancy and upgrade control; clean-core guidance pushes extensions to side-by-side platforms rather than modifying the digital core.

How Odoo, Business Central, Finance & Operations, NetSuite, and SAP S/4HANA implement core architecture choices.
DimensionOdooBusiness CentralD365 F&ONetSuiteSAP S/4HANA
PresentationHTML5/JS via OWLWeb client + apps via IISUnified Dynamics UX + workspacesBrowser UI (Suite UI)SAP Fiori / SAP GUI
Application logicPython + ORM modules.NET server + AL extensionsX++ / extension frameworksSuiteScript + SuiteFlowABAP + code pushdown
DatabasePostgreSQL (shared per DB)SQL/Azure SQL (app DB + tenant DBs)Azure SQL / SQL for F&OOracle multi-tenant shared coreSAP HANA in-memory
Tenancy modelDatabase-per-instance / multi-company in DBMulti-tenant SaaS with tenant DBsDedicated scale unit / enterprise cloudTrue multi-tenant single codebasePublic / private / on-prem options
Extension modelPython modules on ORMAL AppSource or per-tenantISV + Microsoft extension modelSuiteCloud (Script/Flow/SDF)Clean core + side-by-side / ABAP
Integration surfaceXML-RPC / JSON-RPC / controllersOData + SOAP web servicesData entities, dual-write, ODataSuiteTalk REST/SOAP + SuiteQLOData + SAP Integration Suite / events

Deployment topology: tenancy, multi-company, and two-tier

Architecture and deployment are not the same thing, but they interact powerfully. The same three-tier blueprint can be deployed several ways, and the deployment topology changes your cost, isolation guarantees, and upgrade cadence — often more than the feature list does.

The single-tenant versus multi-tenant distinction is the one that matters most for cloud ERP. In a multi-tenant SaaS, many customers share application infrastructure, with business data isolated by tenant — Business Central separates application and tenant databases; NetSuite runs a single shared application instance for all customers. The vendor pushes upgrades on a fixed cadence, patches are automatic, and unit cost is low because infrastructure is shared. The trade-off is less control over timing and less ability to run a bespoke code line. In a single-tenant (or dedicated/on-premise) deployment, you get your own application and database instances, maximum control, and maximum operational cost.

Multi-company and multi-entity design is a second axis that buyers confuse with multi-tenant. Multi-tenant answers 'how is my organisation isolated from other customers of the vendor?'. Multi-company answers 'how do multiple legal entities inside my group share one ERP?'. Most mid-market platforms put several companies in one database or one tenant, with company-scoped masters, intercompany postings, and consolidated reporting. That is efficient when entities share process design and trust the same upgrade train. Separate databases or separate tenants per legal entity buy harder isolation and independent go-lives, at the price of duplicated configuration and more integration for group reporting. Choose multi-company topology for shared ops; choose separate instances when regulations, ownership, or M&A timelines demand hard walls.

Two-tier ERP is an architectural pattern large or multi-entity businesses use to balance control with agility. SAP defines it plainly: the organisation runs different ERP systems at two layers — a Tier 1 backbone at the parent for central functions, and Tier 2 systems at subsidiaries, regions, or acquired companies for local or specialised functions, with integration for master data, process hand-offs, and consolidated analytics. Common drivers include acquisitions that must leave the seller's IT stack quickly, regional branches that cannot absorb a full Tier 1 footprint, joint ventures that need operational independence, and gradual cloud migration while headquarters stays on a heavier core. Typical Tier 2 choices for SMEs and subsidiaries include Business Central, NetSuite, Odoo, or a public-cloud SAP edition — lighter to implement, still feedable into group finance.

On-premise versus cloud-native is the final axis, and for most SMEs it is increasingly a settled question rather than an open one. Cloud-native, multi-tenant deployments have become the default because the vendor absorbs database administration, patching, and scaling — and the architecture (stateless service tiers, managed databases) is designed to make that sharing safe. On-premise remains relevant for highly regulated industries or organisations that need full control of the data layer, but it is a choice with a real, ongoing operational tax. Hybrid two-tier (on-prem Tier 1 + cloud Tier 2) is often a transition state, not a permanent target.

Suite on a shared database vs best-of-breed plus iPaaS

Buyers often hear 'modular' and picture best-of-breed apps glued by an iPaaS. That is a real architecture — and it is not the same as a modular suite on one data model. Confusing the two is how selection decks promise flexibility and delivery teams inherit permanent reconciliation work.

A modular suite (Odoo, Business Central, NetSuite, and similar) keeps independent functional modules on a shared schema. Posting a sales order updates stock and the ledger in one transactional boundary. Your extension model adds behaviour without inventing a second customer master. Integration still exists for banks, tax, e-commerce, and niche tools, but the volume of systems that must agree on truth is small.

Best-of-breed plus iPaaS selects a specialised CRM, WMS, MES, or commerce engine and connects them with an integration platform. You get deeper capability in each domain and can swap a weak component without a full ERP rip-and-replace. You also accept multiple systems of record, eventual consistency, master-data ownership disputes, and a standing cost for mapping, monitoring, and incident triage. Practitioners repeatedly report that connection problems between systems — not greenfield feature gaps — dominate day-to-day pain once the slideware phase ends.

Neither pattern is immoral. The failure mode of the suite is over-customising a shared core until upgrades hurt, or forcing a niche process into a generic module. The failure mode of best-of-breed is underestimating the integration tax: every new SaaS multiplies sync paths, edge cases, and 'who owns this field?' debates. Microservices ERP as a slogan is usually the extreme of the second pattern — service-per-capability with database-per-service — and for SMEs it is almost always a trap unless you already run platform engineering, SRE, and contract testing as core competencies.

Shared-database modular suite vs best-of-breed + iPaaS — trade-offs and typical failure modes.
DimensionModular suite (shared DB)Best-of-breed + iPaaSTypical failure mode
Source of truthOne schema for finance, stock, ordersMultiple stores with syncDrifting masters; finance vs ops mismatch
Transaction integrityACID across modulesEventual consistency across APIsPartial updates; replay storms after outages
Change costConfig/extension in one platformChange spans vendors + mapsEvery release breaks a mapping nobody owns
Skills requiredPlatform admins + one extension stackIntegration engineers + multiple product expertsSME hires can't staff the bus
Upgrade storyVendor train; protect extensionsCoordinate many upgrade calendarsVersion skew freezes innovation
Best fitMost SMEs; limited IT headcountDifferentiated edge + mature integration teamBuying flexibility without paying for ops

Three architecture decisions to make before vendor demos

Feature demos reward the best presenter, not the best architecture fit. Force three decisions first — tenancy, integration style, and extension model — and score every vendor against those constraints. Teams that skip this step often buy a beautiful UI bolted to a topology they cannot operate.

Decision one: tenancy and multi-entity topology. Do you need multi-tenant SaaS with automatic upgrades (typical for SMEs on Business Central or NetSuite), or dedicated/single-tenant control for regulation, custom binaries, or non-standard databases? Inside your group, will legal entities share one multi-company database/tenant, or require separate instances for isolation, local go-lives, or divestiture readiness? Write the answer as a one-pager: who shares data, who upgrades together, who can go offline without taking the group down.

Decision two: integration style. Inventory the systems that must stay (e-commerce, 3PL, banking, industry MES, CRM if it is not in-ERP). If the list is short and stable, a modular suite with a handful of controlled APIs is usually enough. If the list is long, volatile, or includes high-volume commerce, plan for hub-and-spoke iPaaS and/or event publishing from day one — and budget people, not just licences. Event-driven patterns shine when many consumers need the same business fact without hammering the ERP with synchronous calls; they fail when nobody owns the event catalogue or dead-letter handling.

Decision three: extension model. Decide the maximum depth of change you will allow: configuration and standard apps only; upgrade-safe extensions (AL modules, SuiteScript packages, Odoo modules behind standards); or deep custom code in the core. Deep core customisation is how five-year-old implementations become un-upgradeable. Prefer platforms whose extension model matches your team's skills and whose marketplace/ISV ecosystem covers industry gaps so you are not inventing what already exists.

Only after those three decisions should demos happen — and the demo script should force the vendor to show tenancy isolation, a sample multi-company posting, a real API or event, and an upgrade-safe extension, not just a happy-path sales order. Architecture is the part of the product that survives the salesperson.

What this means for buyers: the architecture questions to ask

Architecture is not an abstract concern — it shows up as concrete, askable questions during selection. The vendors that answer these clearly and the ones that dodge them tell you a lot about what you are actually buying. Make the answers before demos, not after you fall in love with a UI.

First, ask where the platform sits on the monolith-to-composable spectrum, and whether that matches your reality. If you are an SME with limited integration resources, a modular shared-database ERP will almost always outperform a composable stack that assumes you can run a permanent integration team. If you are a larger firm with mature platform engineering and genuine best-of-breed needs, composable may pay off — but go in knowing the integration cost is real. Gartner's guidance is sobering on execution risk regardless of approach: it projects that by 2027, more than 70% of recently implemented ERP initiatives will fail to fully meet their original business-case goals, and as many as 25% will fail catastrophically.

Second, ask about the customisation model and how upgrade-safe it is. An ORM-driven, event-based extension model (Odoo modules, Business Central AL extensions, NetSuite SuiteCloud, F&O extension frameworks) is architecturally safer than direct database modification, because upgrades and patches are far less likely to break your customisations. The difference between configuration, customisation, and code-level change is an architectural distinction, and it drives your long-term cost of ownership more than the licence price does.

Third, ask about the data layer: is it a shared database or a set of synced stores, is it multi-tenant with isolated tenant databases, how multi-company works inside a tenant, and what database does it run on? These answers predict your data integrity, your reporting latency, and your vendor lock-in. SAP S/4HANA's binding to HANA, NetSuite's multi-tenant shared core, and Business Central's binding to the SQL family are architectural decisions with real consequences for cost and portability.

Finally, ask about the integration layer's maturity: what APIs are exposed (REST/OData, SOAP, RPC, events), how are they governed and rate-limited, and what does the vendor's iPaaS or connector ecosystem look like? The ERP integration patterns you will actually use live in that layer, and a thin or proprietary integration tier is the most common reason an otherwise good ERP becomes expensive to run. If you want help pressure-testing these questions against your specific stack, an ERP implementation services conversation can map the architecture trade-offs to your business before you commit.

How Flectic can help

Flectic implements ERP on Odoo or Dynamics 365 for companies of 20 to 100 people in the US and Canada, so the architecture choices in this guide are tested against a written scope. Flectic sends a written proposal with a fixed price for each phase before work starts. Review the ERP implementation service against your shortlist. Book a free discovery call with Flectic to start.

Sources

  1. ERP architecture is the technical structure and design principles governing how an ERP organises its components (database, application logic, UI, integration layer); most modern ERPs use a three-tier design (presentation, application, database) so each layer can be scaled or updated independently.

    professionalslobby.comChecked high
  2. Odoo follows a multitier (three-tier) architecture: presentation tier is HTML5/JavaScript/CSS (transitioning to its in-house OWL framework from v15), logic tier is exclusively Python, data tier supports only PostgreSQL as RDBMS; 'everything in Odoo starts and ends with modules'.

    odoo.comChecked high
  3. Business Central's deployment includes three core components — a SQL database (SQL Server / Azure SQL Managed Instance / Azure SQL Database) holding application object definitions and business data, a .NET-based Business Central Server using Windows Communication Framework, and an IIS web server; it exposes SOAP and OData web services.

    learn.microsoft.comChecked high
  4. In a multitenant Business Central deployment, the application and business data are separated into different databases — a single application database can be associated with one or more tenants where each tenant database contains the business data, enabling centralized application maintenance with per-tenant data isolation.

    learn.microsoft.comChecked high
  5. SAP S/4HANA is built on three layers (database, application, presentation); SAP HANA supports both row and column tables in the same database, and modern applications like S/4HANA combine transactions and analytics so HANA is the ideal database for them.

    learning.sap.comChecked high
  6. SAP S/4HANA's architecture is distinct from predecessors and built on three layers (database, application, presentation); the leap to S/4HANA was marked by significant technological advancements over the classic R/3 three-tier model.

    redwood.comChecked medium
  7. Gartner defines composable ERP as an architecture where enterprise applications are assembled from modular building blocks connected through APIs; it evolved from Gartner's earlier 'postmodern ERP' term for a federated mix of core and edge applications.

    cio.comChecked high
  8. A Packaged Business Capability (PBC), per Gartner, is an encapsulated software component representing a well-defined business capability; technically it is a bounded collection of a data schema, a set of services, APIs, and event channels.

    leadingpractice.comChecked medium
  9. Composable architecture — modular and API-first approaches with sets of discrete, task-oriented and independently deployable packaged business capabilities (PBCs) — became a mandatory inclusion capability in the Gartner DXP Magic Quadrant.

    machalliance.orgChecked high
  10. Gartner's ERP strategy guidance predicts that by 2027 more than 70% of recently implemented ERP initiatives will fail to fully meet their original business-case goals.

    gartner.comChecked high
  11. Monolithic ERP is a single unified system where all functions share a common database and codebase; modular ERP allows more flexibility but requires more integration effort; the key difference is how tightly coupled the components are.

    flowsense.solutionsChecked medium
  12. True modular ERP means independent functional modules on a shared data model with consistent governance and replaceable components — distinct from multiple disconnected tools, data silos, or integration chaos.

    axolt.comChecked medium
  13. The defining trait of an ERP is an integrated shared data model rather than disconnected applications, which is what produces one connected system and one source of truth across finance, operations, inventory, and sales.

    ibm.comChecked high
  14. Two-tier ERP is a strategy in which an organization runs different ERP systems at two layers: a parent Tier 1 backbone for central functions and Tier 2 systems at subsidiaries/regions for local or specialised functions; common drivers include M&A, global expansion, joint ventures, and phased cloud migration.

    sap.comChecked high
  15. Dual-write is Microsoft's out-of-box infrastructure for near-real-time, bidirectional interaction between Dynamics 365 finance and operations apps and customer engagement apps via Dataverse schema expansions.

    learn.microsoft.comChecked high
  16. NetSuite is a multi-tenant SaaS ERP where customers share the application instance/codebase; SuiteCloud provides SuiteScript, SuiteFlow, SuiteTalk (REST/SOAP), and SuiteQL; customisations ride the shared upgrade train.

    netsuite.comChecked high
  17. NetSuite exposes SuiteTalk REST/SOAP and SuiteQL; multi-tenant concurrency and rate limits constrain high-volume integration design.

    technologymatch.comChecked medium
  18. Gartner research predicts that by 2027 more than 70% of recently implemented ERP initiatives will fail to fully meet their original business case goals, and as many as 25% will fail catastrophically.

    gartner.comChecked high
  19. Event-driven integration applies event-driven architecture to integration via publish/subscribe, complementing API-led patterns for needs poorly suited to synchronous point-to-point calls.

    solace.comChecked medium
  20. Practitioner consensus on architecture: start with a modular monolith and split only where independent scaling or team ownership is proven; premature microservices add network overhead, consistency risk, and operational complexity.

    x.comChecked medium
  21. Two-tier ERP discussion among practitioners: HQ on heavy Tier 1 (SAP/Oracle) with subsidiaries on lighter cloud ERPs (Odoo, Dynamics, NetSuite); data integration matters more than forcing a single ERP everywhere.

    x.comChecked medium

Frequently asked questions

What is ERP architecture in simple terms?

ERP architecture is the blueprint for how an ERP is built under the hood: how it organises its three layers (presentation, application logic, and a shared database) and the integration layer that connects it to other systems. It determines how hard the system is to customise, how safely it upgrades, how well it scales, and how much it locks you in. Two ERPs can have identical feature lists but very different architectures, and the architecture predicts which one will be cheap or painful to run.

What are the three tiers of an ERP architecture?

The three tiers are the presentation layer (the web and mobile clients users interact with), the application layer (the business-logic engine, validations, workflows, posting routines, often built on an ORM), and the database layer (the shared relational repository of object definitions and business data). Separating these tiers lets each be scaled or updated independently, which is why almost every modern ERP (Odoo, Business Central, and SAP S/4HANA included) uses this structure.

What is the difference between monolithic, modular, and composable ERP?

A monolithic ERP is a single tightly-coupled program where all modules share one codebase and one database, offering deep integration but slow upgrades. A modular ERP keeps the shared database but breaks the application layer into independently upgradeable modules, the architecture most modern cloud ERPs ship. A composable ERP assembles the system from interchangeable, API-connected components (Packaged Business Capabilities) around a lean core, maximising flexibility at the cost of more interfaces to govern. Most SMEs land on modular; composable suits larger firms with mature integration teams.

Why is the shared database so important in an ERP?

The shared database is what makes an ERP an ERP rather than a collection of integrated apps. When finance, inventory, sales, and HR all read from and write to one common data store, transactions stay consistent, reporting is real-time, and master data exists once instead of being duplicated and drifted across systems. It is also the source of the monolith-versus-composable tension: the moment you let capabilities own separate databases and talk over APIs, you regain flexibility but reintroduce the integration problem the shared database was designed to eliminate.

Is a composable ERP always better than a monolithic suite?

No. Composable ERP, which Gartner advocates through its Packaged Business Capability model, trades the built-in consistency and simplicity of a shared-database monolith for flexibility and reduced lock-in. That flexibility is valuable for large firms with mature integration teams, but it reintroduces integration overhead and governance cost. For most SMEs, a modular cloud ERP on a shared data model is the sweet spot, enough modularity to extend and upgrade safely, without running a permanent integration project alongside the business.

How do Odoo, Business Central, and SAP S/4HANA differ architecturally?

All three are three-tier, but they implement the tiers differently. Odoo uses Python for logic and PostgreSQL for data, with an ORM mapping business objects to tables and modules loaded into a database. Business Central is a .NET-based multi-tenant SaaS that separates the application database from isolated per-tenant business databases, extended through AL language extensions. SAP S/4HANA collapses application and analytical workloads onto SAP HANA, an in-memory columnar database, using 'code pushdown' so transactions and analytics run against one dataset.

Where does the integration layer fit in ERP architecture?

The integration layer is a controlled gateway between the shared database and external systems. It exposes the ERP through APIs and web services (OData and SOAP in Business Central, XML-RPC/JSON-RPC and controllers in Odoo, OData services in S/4HANA), so external systems can read and write without touching the core tables directly. Treating integration as its own tier keeps the database clean and auditable; how you design flows across it (point-to-point, iPaaS, event-driven) is where most integration cost hides.

What architecture questions should a buyer ask before choosing an ERP?

Ask where the platform sits on the monolith-to-composable spectrum and whether that matches your integration maturity; ask how upgrade-safe the customisation model is (ORM or event-based extensions beat direct database edits); ask about the data layer (shared or synced, multi-tenant isolation, which database); and ask how mature and open the integration tier is. These architectural answers predict your total cost of ownership and lock-in far more reliably than the licence price or feature checklist.

What is two-tier ERP architecture?

Two-tier ERP means the parent organisation runs a Tier 1 backbone for central finance, governance, and consolidation, while subsidiaries, regions, or acquired companies run a lighter Tier 2 ERP for local operations. The tiers are integrated for master data, process hand-offs, and group reporting rather than forcing every entity onto one heavy instance. SAP and other vendors document common drivers: M&A speed, local regulatory fit, joint-venture independence, and phased cloud migration. For SME groups, Tier 2 is often Business Central, NetSuite, Odoo, or a public-cloud edition of the Tier 1 vendor.

How does multi-company work in an ERP database?

Multi-company (multi-entity) usually means several legal entities share one ERP database or tenant, with company-scoped masters, intercompany transactions, and consolidated reporting. That is different from multi-tenancy, which isolates one customer of a SaaS vendor from another. Shared multi-company is efficient when processes and upgrade timing can align; separate databases or tenants per entity buy harder isolation and independent cutovers at the cost of duplicated setup and more integration for group views. Ask vendors to demo intercompany postings and consolidation, not just a second company switcher.

When is a microservices ERP architecture a trap?

Microservices ERP, many independently deployed services each owning data and talking over APIs, optimises for large teams that need independent scaling and release trains. For SMEs it is usually a trap: you trade ACID consistency for distributed transactions, need contract testing and observability as permanent cost centres, and recreate the integration problem a shared database was invented to solve. Prefer a modular suite on one data model, or a deliberate specialist-tool edge around a lean core with an owned iPaaS/event bus, not a rewrite of the ERP into microservices for its own sake.

Should SMEs choose composable ERP or a modular suite?

Most SMEs should choose a modular cloud suite on a shared data model (for example Odoo, Business Central, or NetSuite) and compose only at the true edge (commerce, specialised MES, banking) through governed APIs or events. Full composable ERP with Packaged Business Capabilities across finance and operations assumes integration maturity many mid-market teams do not have. Use composable thinking to keep the core clean and swappable at the edges; do not use it as permission to assemble your general ledger from six vendors.

More on the blog: Implementation and go-live