Mon – Sat: 9:00 AM – 7:00 PM IST
iDempiere

What is iDempiere?

An open-source ERP with no licence fee — what it covers, what makes it unusually configurable, and who it fits.

In short

iDempiere is an open-source ERP and CRM platform, built in Java on a PostgreSQL or Oracle database, descended from Compiere through ADempiere. It covers finance, purchasing, inventory, sales, manufacturing and CRM. Its distinguishing feature is the application dictionary: windows, fields, validation and business logic are defined as data, so much of what would be development elsewhere is configuration here.

Why It Matters

Why this matters in practice

Two things make iDempiere interesting to a mid-sized business. There is no per-user licence, so adding the fiftieth user is a hosting decision rather than a purchase. And the application dictionary means a new field, a new window or a new validation rule is usually configured rather than coded — which changes both the cost and the speed of adapting it to how you actually work.

No per-user licence fee at any scale
Application dictionary makes most changes configuration, not code
Multi-tenant, multi-organisation and multi-currency out of the box
OSGi plugin architecture keeps extensions separate from the core
How It Works

How it works in practice

The application dictionary

Tables, windows, fields, tabs and validation rules are stored as data. Changing the UI or adding a field is done through it rather than in source code.

Multi-organisation model

A single instance supports multiple legal entities and organisations with shared or separate master data, which suits groups.

Financials and sub-ledgers

General ledger with accounting schemas, payables, receivables, cash and fixed assets, posting from the operational documents.

Operations

Purchasing, inventory with multiple warehouses and locators, sales orders, shipments and invoicing, plus manufacturing through the light manufacturing module.

OSGi plugins

Extensions are packaged as plugins that deploy alongside the core rather than modifying it, so upgrades stay manageable.

Worked example

A worked example: a change that needed no Java

A distributor needs a mandatory field on the sales order capturing a delivery instruction code, validated against a list, defaulted from the customer, and shown on the picking document.

In many ERP systems this is a development task. In iDempiere most of it is Application Dictionary configuration: define the column, add it to the window and tab, attach a reference list for validation, set the default, and add it to the print format. No Java, no build, no deployment — and crucially, nothing that a core upgrade will overwrite, because the dictionary is data rather than code.

The part that does need a plugin is any genuine behaviour: if the code must drive routing logic or push to a carrier integration, that is a model validator in an OSGi plugin. The useful discipline is to establish which layer each requirement belongs in before quoting it — teams that reach for Java first end up maintaining code for things the dictionary would have done, and teams that avoid Java entirely end up with validation logic hidden in callouts where nobody can test it.

Key terms

The vocabulary, briefly

Term What it means
Application Dictionary The metadata layer defining tables, windows, fields and validation — changeable without Java.
OSGi The module framework that lets plugins be added and updated without altering the core.
Callout Logic that fires as a user changes a field, for defaults and dependent values.
Model validator Logic that fires on save or document action, used for business rules and integrations.
Document action The lifecycle operation on a document — complete, void, reverse — each with defined accounting consequences.
What Goes Wrong

Common mistakes worth avoiding

Modifying the core instead of writing a plugin

The quickest way to make every future upgrade painful. Use the plugin mechanism, which exists precisely for this.

Treating free licence as free project

Implementation, data migration and training cost the same as for any ERP. Budget them properly.

Skipping the accounting schema design

Accounting schemas and the chart of accounts drive how everything posts. They are hard to change later.

No support arrangement

An open-source system with nobody who knows it is a liability. Settle support before go-live, not after.

What to measure

Numbers worth tracking

Metric What it tells you What distorts it
Changes by layer How much sits in the dictionary versus plugins versus core. Core should be zero.
Plugin count and size The real custom surface area you maintain through upgrades.
Core modifications Should be zero. Anything above that is an upgrade liability with a date attached.
Version lag How many releases behind current. Growing lag is how open-source systems become legacy.
FAQ

Questions we are asked about this

Both are open source, but iDempiere's application dictionary and multi-organisation accounting model are stronger for complex finance, while Odoo's app ecosystem and interface are generally considered more approachable.
PostgreSQL or Oracle. PostgreSQL is the common choice because it keeps the whole stack licence-free.
Mid-market businesses needing genuine ERP breadth — finance, purchasing, sales, inventory, manufacturing, projects — where per-user licensing is a material constraint and the process needs real adaptation. It is strongest where the implementing team has both accounting depth and Java capability. It is a weaker fit where you want a vendor to underwrite the outcome, or where your processes are entirely standard and a packaged cloud product would need no adaptation at all.
All three are open source and they differ in architecture and depth rather than in licensing. iDempiere's distinguishing features are its Application Dictionary, which makes a great deal configurable without code, its OSGi plugin model for upgrade-safe extension, and accounting depth inherited from the Compiere lineage. Odoo has a larger app ecosystem and a different commercial model; ERPNext is lighter and quicker to stand up. The right comparison is against your actual requirements rather than in the abstract.
A community of contributors and implementation partners, with development happening in public. There is no vendor, which is the point and also the risk. The practical way to assess project health is to look at the evidence directly — commit frequency, release cadence, the number of distinct active contributors, how quickly reported issues get attention. All of that is public, which is more than can be said for most proprietary roadmaps.
Yes, with localisation. GST, e-invoicing, e-way bills, TDS and statutory reporting are implemented through configuration and plugins rather than shipped in the core, so the quality depends on who built your localisation and how it is maintained as rules change. Ask specifically how statutory updates are delivered and who is responsible for them — this is a maintained obligation rather than a one-time setup, and it is the part of an open-source implementation most often underestimated.
Related

Where to read next

Our iDempiere consulting

Read more

What is an OSGi plugin?

Read more

Open-source ERP cost and TCO

Read more

Need this applied to your own systems?

We build and support the systems this page describes. Start with a free working proof of concept — no cost, no commitment.