Why use CRM Core?

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 Drupal components.

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 to make it easy to expand its basic features 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 repeatedly.

With so many other CRM systems out there that integrate with Drupal, why would you want to use CRM Core? There are many ways to answer this question, but here are some things to keep in mind.

The basics

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 duplicate contacts are located and 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

Developers took great pains 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 to work with CRM Core. The majority of components can be managed through drag-and-drop interfaces, and everything can be easily themed using skills you probably already have.

For instance:

• Contacts, activities, and relationships are all entities and can be programmatically manipulated through standard entity hooks.
• Views are 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 overrides the site's primary theme 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. Administrators can easily manage the entire system 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. Administers are empowered to create the interfaces and workflows most appropriate to their situation.

CRM Core was built as a platform to be extended. Users can create small, useful applications that extend the core platform's operations in meaningful ways. Great care has been taken to ensure features are portable and can easily be shared amongst the community through Features and exportable entities. In this way, administrators can easily select the features they find useful and ignore the features 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. Replacing the default matching engine provided by CRM Core with a custom engine is done by turning off the module.

An 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 custom content types, these solutions fail in some key areas:

• Anonymous users: traditional approaches are usually centered on the concept of a "User" and do little to manage information about people without accounts efficiently. There are many 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 activities and relationship types) typically lead 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 has 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 provided with Drupal.

By decoupling contacts and Users and treating each as its own entity, CRM Core seeks to allow developers to work with each one as its own thing. It's entirely possible to build a site that collects contact information from anonymous users and manages the back-end data. 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 use 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 building systems for managing contact information. This enables the development of unique solutions that administrators can easily manage.

Portability

CRM Core aims to handle situations that deal with contact information that is not easily handled using other Drupal modules. The designers seek to address these concerns through portability, using features that expand the system's core functionality.

There is a relationship between complexity and the need for portability. Certain common use cases are difficult to solve in Drupal. They 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 capable of tracking attendance and conducting post-event reporting across various 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 so they can be easily implemented within a website that end-users can configure through a flexible 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.

Simultaneously, several commercial content management systems include 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 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.

There is a FAQ

Look at the FAQ in this handbook for answers to other questions, or ask questions in the issue queue.