This article is by Si Chen from Opentaps:
Having developed open source ERP and CRM for over five years now, I’d like to ask a different question:
Can Open Source make ERP better?
The ERP Challenge
To answer this, we need to look first at the fundamental challenges of business applications such as Enterprise Resource Planning (ERP):
- They’re complicated. Businesses are complicated, so ERP, which must be support all the functions of a business, are large and complicated. This makes them expensive to develop. This is not so bad by itself–lots of software are complicated. But then,
- They require customizations. This is the real killer. Because every business is different, ERP must be tailored to meet the needs of each business. This need for customization adds a lot of work for companies implementing ERP software. More subtly, it also makes it hard to amortize development costs over a large user base.
The unfortunate result: Large, complex software that’s expensive to buy and then expensive and time-consuming to customize and implement.
An Open Source Alternative
Open source ERP software, like opentaps Open Source ERP + CRM, offers users an alternative: fully functional ERP and CRM systems that are freely available, so there’s no cost to start using it. More importantly, because the source code is available, you can customize it to meet your needs. As a result, we’ve been able to reduce the cost of large scale enterprise software dramatically — in some cases by as much as a factor of ten.
But I think we can do even better.
An Open Source Approach to Enterprise Software?
Lately I’ve been asking myself:
Would kind of enterprise software would the open source model create?
In other words, if you had a community of user-developers, each of whom needs to use business software and could contribute to its development, how might they create large scale systems, such as ERP or CRM? Here’s one scenario:
Let’s say there were a “kernel,” which provides a framework for writing business software and some basic but useful functionality. As users needed some new functionality, they could get the kernel and write a module for it. They could then share the modules with each other or sell the module to other users using the same kernel. Over time, as more users and developers show up, more become available, drawing in even more users and developers. Eventually, a large scale system could evolve organically.
This is the open source way, and it is a much better way. Imagine if you could start small and add new functionality incrementally. Instead of costly customizations, you could choose from several off-the-shelf alternatives, one of which might just fit your needs out of the box.
Imagine a world where enterprise software is easy as the iPhone App Store.
Could It Happen with Enterprise Software?
Maybe. The first step is technical. We must come up with a core kernel which is:
- Small, so it could be developed quickly and continually released.
- Useful, so it could draw in a large pool of potential users right away.
- Easy for developing add-on modules.
- Coherent, so all these modules to interact with each other smoothly.
- Fun, so people would enjoy developing with it!
This would be a totally different approach to writing large scale enterprise software.
Even more importantly, though, it would require users to look at enterprise software in a whole new way. Instead of sending out RFP’s listing hundreds or thousands of features, users would need to focus on the add-on modules. Instead of thinking of enterprise software as static pieces of code, we’ll have to think of them as living communities of users and developers.
Are we ready for it?
Are you ready for it?