You sometimes hear: “We can rebuild a complete management app in no-code, no need for an ERP.”
Appealing… but unrealistic for the core of the business. No-code has its zone of excellence; so does the ERP. The real question is not to pick a side, but to assemble in the right place — with a clear, durable architecture that teams can read.
No-code: useful, modular, never monolithic
By definition, no-code lets you design applications and automations without writing code, through visual interfaces. As a result, you move very fast to create interfaces, set up forms, launch automations and build small internal applications; you describe the flows, version the schemas and monitor their execution. In other words: fast implementation and flexible maintenance.
The trap is turning it into a single block that would carry the whole business. A durable no-code setup must remain modular (in building blocks) and connected: modules that orchestrate API calls and event notifications (webhooks), linked to the system of record and to specialized tools — this is the spirit of so-called composable architectures.
What the ERP brings to the core of the IS
An ERP carries the demanding transactional workload: pricing, sales, purchasing, inventory, invoicing, accounting — in parallel and in real time. To sustain these sequences without lag, you need a transactional engine with ACID properties (atomicity, consistency, isolation, durability), indexing, access locking, background tasks, scheduled jobs and idempotence (replaying a flow without creating duplicates). This is what guarantees consistent figures and a single source of truth (SSOT) at company level.
In plain terms: the ERP is authoritative for critical objects (customers, products, orders, prices, stock, invoices). Around it, you plug in whatever speeds things up or specializes — cleanly.
Performance & scalability
Spreadsheet-style no-code databases (e.g. Airtable) are very useful for an MVP. But they quickly show their limits when several people work at the same time, when volumes grow, during activity peaks (inventories, period-end closings) or in recovery after an incident. On top of these functional limits come documented technical ceilings: the Airtable API enforces 5 requests/second per base (and other quotas), which requires careful orchestration and queues on the flows.
Business processes: proven, hence reassuring
Beyond the technology, some routines cannot be improvised:
- Accounting: closings, VAT, reconciliation, audit trail, segregation of duties.
- WMS (logistics): online reservations, lots/serial numbers, FEFO (First Expired, First Out), cycle counts, barcode scanning.
- Manufacturing / Quality: MRP, traceability, controls, non-conformance management.
Rewriting all of this “from scratch” in no-code, then sustaining it operationally and in terms of regulation? Very risky.
Our principles at Auguria (practical, not ideological)
1) ERP at the center — system of record (source of truth) for what must be authoritative: sales, purchasing, inventory, invoicing, accounting.
2) No-code on the periphery — where it excels: interfaces and interconnections (API↔API, webhooks/notifications, messages), easier to maintain and quick to evolve.
3) Specialized tools when the benefit is clear, cleanly connected — for example:
- payment (Stripe, Adyen, Mollie),
- shipping (Sendcloud, Boxtal, Shippo),
- etc.
We keep the ERP as the reference and synchronize only what needs to be.
4) Governance & monitoring are non-negotiable when mixing tools:
- API contracts (versioned schemas, idempotence, error/rate-limit handling);
- Centralized logging, alerts, execution traces;
-
Clear roles and responsibilities (RACI), regular reviews of the flows.
Goal: predictable and observable integrations, rather than a stack of fragile automations.
Concrete example (mental model in 6 steps)
- Order confirmed in the ERP → event emitted.
- No-code picks up the event and orchestrates:
- Payment with a PSP (e.g. Stripe) → status returned.
- Shipping with the aggregator (e.g. Sendcloud) → label + tracking.
- Notifications (email/SMS) → customer & team.
- ERP updates stock / invoice / journal entry; the loop is closed.
The core stays consistent; innovation lives on the periphery.
And what about Odoo?
At Auguria, we recommend Odoo as the ERP foundation (sales, purchasing, inventory, accounting, POS, projects). With partners, we then plug in the specialized applications and no-code workflows that bring real added value — while keeping simple, documented and monitored interfaces. It is our way of honoring the common sense of the past while leaving room for tomorrow’s agility.
In short
- ERP at the core for consistency and enforcement of rules (ACID, idempotence, etc.).
- No-code around it to move fast and adapt the interface without disturbing the system of record.
-
All of it modular, never monolithic, governed and observable.
This is how you move forward with confidence, without losing either the tradition of good processes or the drive to innovate.
Useful references: definitions of no-code (JDN, Impli), ACID properties and SSOT (Wikipedia / Astera), FEFO in logistics (Mecalux), Airtable API limits (Airtable Support).