Open Source CRM and ERP: Bending the Back Office

SugarCRM, Openbravo and Compiere tap the power of open source development to make customization easy, but the line between community and commercial is quickly crossed.

1 2 3 Page 2
Page 2 of 3

The system mixes the job of herding the sales force with the order fulfillment processes. There are sections for managing the banking, procurement, production, and warehousing operations as well.

Openbravo is also mainly a collection of database tables with a pretty front end. It is written in Java with many of the classic Java libraries like Hibernate and JasperReports. The front end is built out of a custom templating engine that takes XML files and renders them in HTML. If you want to create custom forms and data structures, you'll work directly with the templating engine.

The Web pages are pretty straightforward, but they're not particularly AJAX-like. There's a good reason for that: Openbravo aims to make it possible to navigate with the keyboard alone, a capability that's pretty popular at offices where people need to work through form after form. This feature isn't perfect; there was one glitchy moment when I found one form wouldn't work because I wasn't logged in with sufficient permissions.

The Openbravo app is not as polished as many Web sites, but I don't think anyone will notice after spending 15 minutes getting oriented. The designers have done a good job producing something as efficient as the old "green screen" VT100-grade tools that dominated the back offices in the era of mainframes and mini computers.

The big version of Openbravo, the one that wears the ERP acronym, only works with Oracle and Postgres. They're said to be working on supporting DB2 and MySQL, but a number of custom hacks in the code apparently make it difficult to convert directly to MySQL. This professional version is also available as an "appliance" kit that offers one big, fat, licensed bundle with Tomcat, Oracle, and Apache. A lighter-weight version offers a point of sale (POS) application that can work with MySQL today.

There's a fair amount of flexibility for developing new modules -- more of a necessity for an ERP installation. Every business is different, and while the standard framework is pretty flexible, there's always room for more tables and modified control logic. The development documentation is pretty thick with a fair number of examples. Most of the time is devoted to picking up the structure of the system and the way that the XML files and Java code are turned into tables and forms.

Openbravo doesn't have the same kind of extensive plug-in system as SugarCRM, which limits the way that developers can bundle their features and toss them around. This doesn't mean that the system can't be extended -- it can very easily -- but there's no simple way to pull together a number of enhancements. On the other hand, I've found that plug-in architectures can be a real headache for developers because the plug-ins will eventually find a way to step on each other's toes.

Openbravo's open source community is not as robust as SugarCRM's. There are only 57 projects listed at the company's forge, and many of them are aimed at localizing the language. The wiki, which is much more extensive, is the preferred way to get documentation. They've also done a nice job producing a number of videos, an increasingly common way to tell developers how to get something done.

Openbravo's form system allows you to add new rows to the tables holding data about the clients. The forms can automatically enforce standard rules to prevent important data from being left out.

There are no differences in software features between the community edition and the two commercial editions, but you do get "unlimited bug support" and "installation support" with the paid versions. Openbravo will also sell a hosted version that comes with an Oracle license and a server. I'm guessing that many customers will also look at hiring some of the Openbravo developers to help customize the code. This kind of in-house knowledge is often worth the price.

Compiere ERP and CRM: Form-ed for customizationThe Compiere package takes its name from the Italian verb for "accomplish" or "fulfill." It comes with both acronyms, ERP and CRM, indicating that it handles the two jobs pretty well. Like Openbravo, it is a set of database tables built to track customers, products, and the transactions between them. And like SugarCRM it offers a fairly sophisticated set of routines for juggling your customers and reaching out to them.

The Compiere system is built in Java and uses either Oracle or Postgres. Support for any JDBC database is said to be coming eventually. Ports to MySQL, Sybase, and Firebird are said to be in beta now.

The Compiere Web interface is similar to those of Openbravo and Sugar. There's a menu of options for tables, and you can drill down to add new lines to the tables or search for old ones. I floundered for a few minutes before I discovered that it was possible to drill down into subforms, something that's necessary when the database is forcing you to make sure that the client name you put down on an invoice matches a real client in the client table. There are a fair number of AJAX-like features for completing the forms and searching the table, although the tools for filling out the forms seemed easier to use for me. In general, it's a pretty modern interface.

I discovered the biggest gap between the community version and the professional version when testing Compiere's tools. The community version took a morning to install, and I found myself flummoxed by the client that would constantly keep resetting the Postgres port to 5444. The professional version, on the other hand, started up in about 15 minutes once I added the newer EnterpriseDB version of Postgres.

The basic community version of Compiere dates from the era when the browser wasn't as sophisticated and AJAX was just a kitchen cleanser. The community version interacts with the central database using a custom Java client. You need to buy the newer professional version to get the modern and more convenient Web-based interface.

More features start appearing once you start paying. Documentation is not free unless you sign up for the standard version ($25 per seat per month). Reporting tools are also tossed in. To get the Web-based interface you must spring for the professional edition ($50 per seat per month), a level of service that also includes unlimited support requests and other assorted bug fixes. There's also a "cloud edition" ($66 per seat per month) that wraps the professional edition into a pre-built image for Amazon's EC2.

There's not as much openness with Compiere as with SugarCRM and Openbravo. There's no open bazaar of plug-ins, nor is there much obvious energy devoted to modifying the code. Most of the threads on the forum hosted at SourceForge seem focused on installation problems. I'm not sure why. It isn't because the system is closed. In fact Compiere includes a pretty nice set of APIs and tools for calling external pieces of code.

The AJAX-enabled collection of forms for Compiere includes a number of pop-up divs that handle adding new data entries on the fly. This enforces the constraints on the tables by forcing users to fill in the entries for the sub table before adding the main rows.

Most of the customization energy is built into the tools now. Compiere calls its customization process "model driven," which means that you just start adding the columns to the tables in the data models and Compiere does most of the rest. Adding a field to a form means filling out several additional forms, an act that left me wondering whether forms begetting more forms meant that they were a life force all of their own.

One piece of Compiere documentation promised that the customization process required no "error-prone procedural programming," which I thought was a pretty accurate description. Adding new lines to the forms and building new rules for them is programming, it's just not at the grungy Java level. The developers took their ERP mechanism and applied it to managing the source code itself.

[ Need a Linux that can squeeze into a pen drive, resurrect old hardware, or create a security or storage appliance? See "Specialty Linuxes to the rescue" and "More specialty Linuxes to the rescue." ]

Turns in the open roadWhich should you choose? The most important criteria is one that can't be answered in a general review like this one. Each business has different needs, and it's hard to assess whether any of these even match the general workflow. The best tool with the most features can be a horrible fit for an organization if its internal architecture depends upon some structure to the workflow that doesn't work with your business. Sometimes it may be more expensive to shoehorn a large operation into a standard product like these than it would be to write custom software from scratch.

While it's doubly foolish to mix stereotypes of people with generalizations about software, I think that Openbravo is like guys in the warehouse: They want to fill orders and deliver the goods. SugarCRM is like the hail-fellow-well-met hand shakers who know that much of the sales process depends upon getting in front of people and keeping track of their needs. Compiere is a bit of a mixture of both, but is dominated by the spirit of moving material through the warehouse.

But just as humans can move between roles, software can too. These systems are all open collections of database tables and rules for editing them. If something is done with one of them, it can be rewritten for any of the others. There's no reason why Openbravo can't act more like the smiling, backslapping SugarCRM, and there's no reason why SugarCRM can't add the right plug-ins and start working in the warehouse.

In all three cases, customization is simple enough that it is becoming harder and harder to choose to build your own. It would be pretty silly to write your own back office in Java or C++ today, not only because so much functionality is already there for the taking, but because these systems are close to being languages themselves. The combination of the open source development and the rise of a plug-in architecture means that it's easier and easier to modify what exists. These apps were designed to accept the contributions of everyone, and this flexibility is baked into the entire development cycle.

Still, these three projects are a far cry from the image of a programmer-led commune where everything is shared equally. These are professional companies first and foremost, and they sell a product that they also happen to give away. Will the free, open source edition meet your needs? It may not be simple, but a skillful programmer should be able to install all of them and get them storing data in a reasonable amount of time.

Whether the community edition is the most cost-effective solution depends largely upon the nature of your business and the need for customization. If your customers and products map directly onto the simple table structure, then it's possible to do quite well with the community editions. After all, you can even build replacements for some of the commercial features that aren't included in the free edition. Simple reporting features, for instance, can be whipped together with JasperReports because it's always possible to tie into the database without going through the main application.

Doing all of the work yourself, though, may be much more trouble than it's worth. I've found that it often doesn't take much time to do the programming work itself, but it can take a long time understanding the architecture and deciding how to implement the changes. It takes time to build up the expertise. While $50 per seat per month adds up pretty quickly, it's much less expensive than hiring a full-time programmer for a big part of the year.

[ See the best that open source has to offer -- in collaborationdeveloper toolsenterprise applicationsnetworkingplatforms and middleware,productivity applicationssecurity, and storage -- in InfoWorld's Bossies 2008. ]

The professional versions do include more support and -- in the case of Compiere -- access to the documentation. This is often pretty valuable, but it still requires you to do the actual customization work. None of the professional versions include this work -- that's your responsibility -- but the companies all support a network of programmers who are versed in the idiosyncrasies of each version. Even companies with a deep collection of programmers will want to consider hiring some help when installing these packages.

It's also important to take note of the amount of openness built into the products themselves. Customizing Openbravo, for instance, involves creating XML and Java classes. The results need to be compiled. SugarCRM now includes a very sophisticated drag-and-drop tool for adding tables and modules to your implementation. You can add fields and control how they appear without writing any ASCII text. All of the programming is done "visually" with AJAX-level dragging and editing of divs on the screen. It's a very nice level of openness that will be accessible to many managers and users without direct programming experience.

I should say that while SugarCRM's drag-and-drop tool makes it much easier to change tables and data models, it doesn't remove the need to think ahead about how the data will be used by everyone. It may be dangerous to let everyone add fields as they see fit because it can lead to a loss of coherence.

1 2 3 Page 2
Page 2 of 3
Discover what your peers are reading. Sign up for our FREE email newsletters today!