CRM Best Practices
Recommended practices distilled from across the CRM configuration guides, covering module design, field setup, layouts, dependencies, records, and permissions. Each section below corresponds to its own detailed walkthrough.
Getting Started
The five-step flow, enable, configure, manage, communicate, analyze, is intended to be followed in sequence.
- Confirm the CRM module is enabled before configuring. It's on by default, but verifying under Configuration → System → Modules avoids wasted effort configuring a module that isn't active.
- Configure fields, relationships, layouts, and dependencies together. These four building blocks are interdependent; treating them as one planning exercise, rather than four separate ones, produces a more coherent module.
Default Modules
Not every built-in module is editable to the same degree.
- Check a module's schema tier before planning changes to it. Full schema modules (Contacts, Organizations, Tickets, Leads) support complete customization; locked schema modules (Groups, Telephony, Users) do not expose their fields for editing at all.
- Expect hidden modules to stay off the main navigation by design. Attachments and Comments are intentionally hidden and reached only through their parent module's relationship field, not through their own menu entry.
- Treat auto-generated Reference fields as read-only system artifacts. They appear automatically wherever another module's Relationship field points at this one, and they aren't meant to be added or edited by hand.
Internal Modules
Source Type is the one decision on a module that can't be revisited later.
- Decide Internal versus External before creating the module. Source Type locks in permanently once the module is saved; switching later requires recreating the module entirely.
- Default to Internal unless an external system genuinely owns the data. Internal is the default for good reason: it unlocks the full field, layout, dependency, and relationship builder with no outside integration to maintain.
External Modules
An External module is a display layer over a connected system, and needs its connection set up correctly before it's usable.
- Set up the API Integration collection first. The collection, its base URL, and its endpoints need to exist under Configuration → Integrations → API Integrations before they can be mapped to a module.
- Always mark a primary key field. An External module stays unusable, with a visible warning, until one field on the Fields tab is marked as the unique identifier used to match records back to the connected system.
- Only map the endpoints the integration actually supports. Post, Update, and Delete are optional for a reason: leaving them unmapped simply removes that action from the module instead of breaking it, appropriate for a read-only connected system.
Configuring a Module
The basics set on a new module carry through everywhere it's referenced later.
- Write a clear, concise Module Name. It's the label displayed throughout the entire system, so clarity here pays off in every menu, card, and form that references it later.
- Use Hidden intentionally, not as an afterthought. Leave it off for modules meant to be used right away; switch it on only when a module needs to exist without appearing in menus yet.
Configuring Fields
Several field settings lock in at save time, so getting them right up front avoids a rebuild later.
- Choose the correct field type and sub-type before saving. A Text field's Short versus Long choice, and a Relationship field's Related Module and Relationship Type, all become fixed once saved.
- Set Relationship Type explicitly; it doesn't default for you. Saving a Relationship field without choosing a type fails silently rather than with a visible error, so confirm it's set before saving.
- Use the Required backfill default carefully on modules with existing data. Turning Required on for a populated module prompts for a one-time default value to backfill existing blanks; choose that value deliberately rather than accepting a placeholder.
- Avoid combining Unique and Required on a module that already has records. The combination isn't allowed once data exists, unless the field already carried both settings from the start.
Managing Modules
Viewing, editing, and deleting a module each carry a different level of risk.
- Review a module in its read-only view before editing it. Opening a module loads it read-only by default, giving a safe way to check its configuration before switching into Edit Module.
- Treat deletion as permanent and irreversible. Deleting a module removes its fields, layouts, and every record permanently; typing the exact module name to confirm is the only safeguard, and there is no undo.
- Reserve deletion for modules created directly, not the built-in defaults. Built-in default modules are generally meant to stay off-limits for deletion.
Configuring Layouts
Layouts control arrangement only, and each of the four types has its own quirks worth knowing in advance.
- Establish relationships before relying on Table, Thread, List, or Grid View blocks. Thread, List, and Grid View only offer modules already related to the one being laid out, with no non-related fallback; Table alone supports a Non-Related Module option.
- Verify a Form Layout's sections against the live create form after saving. A Form Layout's section groupings don't automatically reshape the real New Record form, so confirm the live behavior matches expectations rather than assuming the builder's preview is the final result.
- Default a shared layout to Restricted access. Opening it up to Users with module access, and choosing Can view versus Can edit deliberately, keeps a layout's audience intentional rather than incidental.
Full walkthrough: Configuring Layouts.
Configuring Dependencies
Dependencies change immediately on the live form, which makes it easy to lose track of exactly what's been committed.
- Pick dependency fields in the correct parent-to-child order. The order checked in the Fields multi-select sets the chain direction; the first field picked controls the second, not the other way around.
- Use the edit view's per-node delete instead of the top-level delete icon when removing a single mapping. The top-level delete on a saved dependency removes the entire entry immediately, with no confirmation prompt; the per-node delete inside the edit view removes just one branch.
- Confirm the live form reflects the saved mapping before moving on. Testing the actual dropdown or relationship picker after saving catches any mismatch between what was intended and what was configured.
Full walkthrough: Configuring Dependencies.
Records Management
Day-to-day record handling has its own set of habits worth building in.
- Use the History panel as the audit trail of record. Every CREATE and UPDATE event lists exactly which fields changed and their before/after values, newest first.
- Choose Ignore or Overwrite deliberately when importing. Ignore skips records that already exist, avoiding accidental duplicates; Overwrite replaces them, which is only appropriate when that's genuinely the intent.
- Apply filters before exporting when only a subset is needed. Export writes exactly what's on screen: every record with no filter applied, or only the filtered subset once one is active.
- Treat record deletion as final. A record and anything tied to it through a relationship field pointing at it are gone permanently once the delete confirmation is accepted.
Configuring Permissions
Permissions split cleanly into configuration access and record access, and conflating the two is the most common misconfiguration.
- Keep CRM Configuration and CRM Module permissions distinct. Manage Configuration, Delete Module, Create Layout, and Create Fields govern schema changes; they grant nothing toward viewing, creating, updating, or deleting actual records, which is governed separately by CRM Module Permissions.
- Scope Update, View, and Delete to Own, Group, or All deliberately per role. Choosing the narrowest access level that still lets a role do its job limits exposure of records that role doesn't need to reach.
- Apply field-level permissions for sensitive fields. Edit Mapping on a module's permission row narrows Create, Update, and View down to individual fields, useful when only part of a record should be restricted rather than the whole thing.
Full walkthrough: Configuring Permissions.