Voting starts in March for the Drupal Association Board election.
CRM Core is a set of modules for managing contacts, activities and relationships within your Drupal website. It is designed to provide a basic framework for managing these items and interacting with other components of Drupal.
CRM Core is not a contact relationship management system itself, so much as a tool for developing your own systems for managing contact relationships. It was built in a way that makes it easy to expand it's basic features in meaningful ways by creating small, useful applications that extend what it can do. In this sense, CRM Core can be considered a platform within Drupal for creating your own CRM systems, which are portable, reliable and can be implemented over and over again.
With so many other CRM systems out there that integrate with Drupal, why would you want to use it? There are a lot of ways to answer this question, but here are some things to keep in mind.
You can expect to find the following basic features within CRM Core modules:
- Tracks contacts, relationships and activities.
- Contacts, relationships and activities are all fieldable entities, meaning you can add as many custom fields as you want.
- The user synchronization module allows administrators to tie contacts to user accounts.
- The match module allows administrators to define rules for how duplicates are located in the system, and provides a flexible framework for building customized identification schemes.
- The report module provides a centralized location for storing reports related to contacts.
- A variety of bulk operations for merging contacts, putting people into households, sending messages via email, and the like.
Designed for Drupal people
Great pains were taken to ensure CRM Core can be easily managed by anyone who knows how to work with Drupal. The designers wanted to ensure no one requires any specialized knowledge in order to work with the system. The majority of components can be managed through drag-and-drop interfaces, and everything can be easily themed using skills you probably already have.
- Contacts, activities and relationships are all entities. They can be programmatically manipulated through any of the standard entity hooks.
- Views is used in nearly every situation where information about contacts is presented. This means nearly every screen in the system can be easily manipulated and modified to appear in the manner of your choosing.
- Administrators can configure a separate theme for the CRM section of a website, which can override the primary navigation of the site to something of your choosing. This means you can control the look and feel of the interface for accessing contact information.
- The administrative features in CRM Core are all organized logically according to community standards. The entire system can be easily managed through an admin menu.
Just the features you need
CRM Core is built as a platform that provides basic functionality for managing contacts, and nothing else. Developers, site administrators, and users are not forced to track information about contacts in any specific way, these groups are empowered to create the interfaces and workflows most appropriate to their situation.
Platforms are designed to be extended. CRM Core was built so that users can create small, useful applications that extend the operations of the core platform in meaningful ways. Great care has been taken to ensure features are portable and can easily be shared amongst the community through the use of features and exportable entities. In this way, administrators can easily select the features that are useful in their specific use case, and ignore the ones that are not.
This philosophy extends down to the core modules themselves. The user interface for CRM Core itself can be turned off and replaced with something different. The default matching engine provided by CRM Core can be replaced with other custom matching engines simply by turning off a module.
Innovative way to use Drupal
Content management is not contact management.
While it's possible to capture basic contact information about a person through modules like Profile2 and through custom content types, these solutions fall down in some key areas:
- Anonymous users: traditional approaches are usually centered on the idea of a user, and do little to efficiently manage information about people without accounts. There are a lot of situations where it's inappropriate to have users creating accounts in the first place.
- Multiple dimensions of data: while it's easy to capture basic contact information, the complexities of tracking multiple dimensions of data (such as multiple activity and relationship types) typically leads to one-off solutions that are resistant to being employed as a generalized approach.
- User Interface: Drupal sites generally have a front end and a back end, each of which have a specific purpose. There is no strong UI for managing contacts, despite the fact the needs of users are dramatically different.
CRM Core was designed to address each of these issues in a thoughtful way that avoids creating additional drawbacks for administrators and developers. It makes things easier to do and represents an innovation in the solutions that can be provided with Drupal.
By decoupling contacts and users, and treating each as it's own entity, CRM Core seeks to allow developers to work with each one as it's own thing. It's entirely possible to build sites that collect contact information from anonymous users and simply manage that data on the backend. This would not be easy to do with traditional approaches.
By providing a standardized approach for working with contact information, CRM Core provides a way for developers to easily share more advanced features that build off a common set of tools. This enables more sharing and fewer one-offs, which is hard to achieve using the standard tools that ship with Drupal.
By providing a separate UI for the CRM system itself, CRM Core increases the usability and reduces the complexity of the task of building systems for managing contact information. This enables the development of unique solutions that can be easily administered.
CRM Core aims to handle situations that deal with contact information that are not easily handled using other tools that are part of Drupal. Part of the way the designers seek to address these concerns is through portability, using features that expand the core functionality of the system.
There is a relationship between complexity and the need for portability. Certain common use cases are simply difficult to solve in Drupal and would benefit from a common approach to managing information about people that can be generalized to fit many cases. A good example is event registration. While it is easy to stand up a form that tracks registrations for a specific event, it is not trivial to put together a system that is also capable of tracking attendance and conduct post-event reporting across a range of events. While it's certainly possible to deliver a solution given the appropriate time and resources, the cost to implement this can be high compared to using a third-party system.
A good feature for CRM Core (which, incidentally, is almost ready to be released) might provide the tools to do this in a way where they can be easily implemented within a website, in a flexible manner that can be configured by end-users through a web-based administrative interface. Having the ability to port this kind of tool from site to site will reduce the time it takes to implement such a solution and allow developers to focus on other aspects of a build out, thus diminishing the potential for one-off solutions or the need to go outside the Drupal platform for key features.
There is no end to the kinds of use cases that involve tracking information about people in complex ways. Through the development of a community of contributors creating portable features, the designers seek to establish an open-source ecosystem around contact management in Drupal similar to the one discussed in this post from Dries Buytaert's blog.
Addressing Competitive Concerns
Managing information about people is a complex task, and it's something Drupal traditionally is not good at.
At the same time, there are a number of commercial content management systems that include substantial CRM features as part of the platform. In general, these features are used to capture information about people, generate demographic / psychographic reports, personalize the presentation of content, and automate communications, amongst other capabilities. This is an important competitive advantage proprietary platforms use to keep customers locked in, through the use of value-added features that are not readily available in their open source equivalents.
CRM Core seeks to break this lock-in cycle by a) making Drupal able to efficiently work with contact information and b) providing a platform through which developers can build features capable of doing a lot more than their commercial equivalents. CRM Core was designed so that developers can integrate contact management features with any other component within Drupal, which is a pretty big stick to consider compared to the feature sets of most proprietary products.