How iDempiere keeps your customisations separate from its core — and why that separation is the whole point.
OSGi is a Java module system that lets components be installed, started and stopped independently. In iDempiere, customisations are packaged as OSGi plugins that register themselves with the core at runtime rather than altering it. The practical consequence is that you can upgrade the core without reapplying your changes, because your changes were never inside it.
The single most expensive mistake in any ERP is customisation that cannot survive an upgrade. Estates that modify core code end up either frozen on an old version or paying to reapply changes at every release. The plugin model removes that choice: the core is replaced, the plugins are re-deployed, and the boundary between them is explicit.
Register against document events — before save, after complete — to add validation or trigger behaviour without touching the base class.
Override or extend the behaviour of a business object by supplying your own implementation through the factory.
Custom processes appear in the menu like standard ones; callouts react to field changes in a window.
Application dictionary changes travel with the plugin as 2Pack, so configuration and code deploy together.
The plugin is dropped into the runtime and started. No core rebuild, and it can be stopped if it misbehaves.
Two businesses run the same open-source ERP with similar customisation: additional validation on sales orders, a custom tax calculation, and an integration to a carrier.
The first implemented all three by editing core classes. It works. At the next release, every edited class has to be compared against the new version and the changes merged by hand — by someone who did not write them, from a diff rather than from intent. The upgrade becomes a project with testing, a window and a risk register, and the business starts deferring it. Three releases later it is effectively on a private fork.
The second implemented the same three as OSGi plugins registering services at defined extension points. The core is untouched, so it is replaced wholesale at upgrade. The plugins are tested against the new version and redeployed. The upgrade is a maintenance task rather than a project, which means it actually happens — and the compounding benefit is that the business stays current rather than accumulating a decade of deferred releases.
| Term | What it means |
|---|---|
| Bundle | The deployable unit — a JAR with metadata declaring what it provides and requires. |
| Service | A component one bundle publishes for others to use, resolved at runtime rather than compile time. |
| Lifecycle | Bundles can be installed, started, stopped and updated while the application keeps running. |
| Dependency resolution | The framework matching what a bundle needs against what others provide. |
| Classloader isolation | Each bundle has its own classloader, so versions can coexist without conflict. |
It is never once, and it is never documented. Every subsequent upgrade pays for it.
Dictionary changes made by hand in one environment and by 2Pack in another diverge quietly. Package them.
A single plugin containing everything cannot be stopped selectively. Split by functional area.
Plugins need version numbers that track which core release they were built against, or upgrades become guesswork.
| Metric | What it tells you | What distorts it |
|---|---|---|
| Core modifications | The number that decides whether upgrades are routine or expensive. Target zero. | |
| Plugins with automated tests | Whether upgrade verification is a script or a fortnight of manual checking. | |
| Plugin build reproducibility | Can every plugin be rebuilt from source today, by someone else? A surprising number cannot. | |
| Time to apply a release | The outcome measure. Falling time means the architecture is working. |
We build and support the systems this page describes. Start with a free working proof of concept — no cost, no commitment.