In This Article
- 5 Implementation Principles
- Best Practice 1: Data Migration — Clean Before You Move
- Best Practice 2: Configuration Over Custom Code
- Best Practice 3: Permission Model Design
- Best Practice 4: Adoption-Driven Training
- Best Practice 5: Integration Architecture
- Salesforce Governance Framework
- 7 Implementation Pitfalls
- Go Deeper
5 Implementation Principles
| Principle | What It Means | Violation Consequence |
|---|---|---|
| User-first design | Design for end users, not managers | Low adoption — system serves reporting, not working |
| Configuration over code | Use clicks before code — 80/20 config/custom | Expensive maintenance, upgrade fragility |
| Clean data only | Cleanse before migration, not after | Dirty data destroys trust in the system |
| Iterative delivery | Build in sprints with user feedback | Big-bang delivery with months of rework |
| Adoption is the metric | Success = users use it daily | Technically complete but practically unused |
Best Practice 1: Data Migration — Clean Before You Move
Data migration is the #1 implementation risk. Dirty data migrated to Salesforce produces: duplicate accounts (the same customer entered 3 times with different spellings), stale contacts (emails that bounce, phones that disconnect — reps lose trust), incomplete records (accounts with no address, contacts with no email), and inconsistent formatting ("USA" vs "US" vs "United States" vs "U.S.A."). The rep who finds their first 5 records are wrong stops trusting the system — and goes back to their spreadsheet.
Migration Methodology
Step 1: Audit existing data (1 week). Profile every source: record count, completeness rate per field, duplicate rate, last-updated dates. Identify: which records are active (contacted in last 12 months), which are stale (no activity in 24+ months), and which are duplicates.
Step 2: Cleanse (2-3 weeks). Deduplicate using fuzzy matching (same company name + similar address = duplicate). Standardize formatting (country codes, state abbreviations, phone formats). Validate emails (syntax check + deliverability check). Enrich missing data (company size, industry from D&B or ZoomInfo). Remove stale records (no activity in 24+ months → don't migrate).
Step 3: Map and transform (1 week). Map source fields to Salesforce fields. Transform values (source system's stage names → Salesforce stage names). Handle lookups (link contacts to accounts, opportunities to accounts).
Step 4: Migrate and validate (1 week). Test migration with 10% sample → validate record counts, field mapping, relationships, and data accuracy. Fix issues. Full migration. Post-migration validation: record counts match, key records verified by business users, reports produce expected results.
Migrate less data, not more. Every record migrated is a record that must be maintained. Migrating 100,000 accounts when 20,000 are active creates: 80,000 records cluttering search results, inflating report counts, and degrading data quality scores. Migrate active records. Archive the rest. The clean Salesforce org builds trust from day one.
Best Practice 2: Configuration Over Custom Code
Every custom Apex class is a future maintenance liability — it must be: tested with every Salesforce release (3 times per year), maintained by a developer (not an admin), and documented for the next developer. Configuration (flows, validation rules, page layouts, formula fields) is: maintained by admins (cheaper, more available than developers), upgrade-safe (Salesforce upgrades don't break declarative configuration), and visible to non-developers (business analysts can review and modify).
When to Use What
| Requirement | Approach | Tool |
|---|---|---|
| Field validation | Configuration | Validation Rules |
| Process automation | Configuration | Flow Builder (not Process Builder — deprecated) |
| Email automation | Configuration | Flow + Email Template |
| Approval routing | Configuration | Approval Process |
| Complex calculation | Configuration first | Formula Field or Flow |
| External API integration | Custom code | Apex + HTTP Callout |
| Complex UI component | Custom code | Lightning Web Component |
| Batch data processing | Custom code | Apex Batch |
Best Practice 3: Permission Model Design
Salesforce permissions control who sees what data and can do what actions. A poorly designed permission model produces: reps who can see other reps' accounts (competitive team dynamics break), managers who can't access their team's data (reporting broken), and users who can delete records they shouldn't (data loss). The permission model: Profiles define object-level access (which objects can this role see/create/edit/delete). Permission Sets add specific permissions (elevated access for specific features). Sharing Rules control record-level access (reps see only their accounts; managers see their team's). Role Hierarchy defines the management chain for data rollup.
Design principle: least privilege. Start with minimum access. Add permissions as needed — never the reverse. The Sales Rep profile: can read all accounts (for prospecting), can edit only their own opportunities, can create but not delete contacts, and can view but not edit products/pricing. The Sales Manager: inherits rep access + can view and edit all team opportunities + can run team reports + can manage team members. Build from restricted upward — not from "everyone can do everything" downward.
Best Practice 4: Adoption-Driven Training
Training that produces adoption teaches workflows, not features. The wrong training: "here's how the Opportunity object works — fields, page layouts, related lists, reports." The right training: "here's how you move a deal through your pipeline in Salesforce — log a call, update the stage, attach a proposal, request manager approval, and close the deal."
Training format: 2-hour hands-on session per role (not 8-hour classroom). Participants use their own data (migrated during build phase). Each participant completes: the 5 most common tasks for their role during the training session. Followed by: recorded 5-minute micro-tutorials for each task (accessible in Salesforce via in-app guidance). And: champion-led office hours (30 minutes weekly for the first 8 weeks).
Measuring adoption: Daily active users (target: 80%+ of licensed users within 30 days), records created/updated per user per week (target: increasing trend), feature usage (which features are adopted, which are ignored), and satisfaction survey at 30 and 90 days (target: 4+ out of 5). Low adoption in specific teams triggers: team-specific training reinforcement, workflow simplification review, and champion engagement with non-adopters.
Best Practice 5: Integration Architecture
Salesforce integration best practices: use native connectors first (Salesforce for Outlook, Salesforce for Gmail — zero-config email and calendar sync), use middleware for complex integration (MuleSoft for multi-system orchestration, Azure Logic Apps for Microsoft ecosystem integration), never build direct database connections (always through Salesforce APIs — database connections bypass security, validation, and audit), and handle errors gracefully (integration failures shouldn't block the user — queue the sync and retry, don't show an error that confuses the rep).
Common integrations: Email/Calendar (native Salesforce connector — deploy in week 1), ERP (account and order sync — API or MuleSoft), Marketing (Pardot/Marketing Cloud — native integration), Support (Service Cloud — same platform), and Analytics (data platform — Salesforce Connect or ETL extraction for advanced analytics beyond native reports).
Salesforce Governance Framework
Change management: All configuration changes go through: sandbox development → sandbox testing → production deployment via change set or DevOps pipeline. No direct production changes — ever. Even "small" changes (add a picklist value) follow the process because: changes have unintended consequences, audit trail is maintained, and the practice is established before the first urgent "just fix it in prod" request.
Data governance: Duplicate management rules active (prevent duplicate account creation). Required fields enforced for data quality (but minimized — only fields genuinely needed). Data steward assigned per business unit (quarterly data quality review). Scheduled data enrichment (annual refresh of account data from D&B or ZoomInfo).
Security governance: Quarterly user access review (deactivate departed employees, review permission assignments). Field-level security audit (sensitive fields — revenue, margins — restricted to appropriate roles). Login history review (identify unused licenses for reallocation).
7 Implementation Pitfalls
Too Many Custom Fields
Pitfall: 200 custom fields because every stakeholder requested their data point. Fix: Each field must pass the "will a rep fill this in?" test. If not, it's a reporting field that should be calculated or imported — not manually entered.
Migrating Dirty Data
Pitfall: Migrate everything from the old system. Fix: Cleanse before migration. Migrate only active records. Archive the rest.
Over-Customization
Pitfall: Custom Apex for everything. Fix: 80/20 rule — 80% configuration, 20% custom code. Every custom class is a maintenance liability.
Big-Bang Rollout
Pitfall: Build for 6 months, deploy to everyone on Monday. Fix: Iterative sprints with user feedback. Pilot group first (50 users), then expand.
Feature-Based Training
Pitfall: "Here's how Salesforce works." Fix: "Here's how YOUR workflow works in Salesforce." Role-specific, task-based, hands-on.
No Post-Launch Optimization
Pitfall: Implementation team leaves at go-live. Fix: 30-day hypercare + quarterly optimization reviews for 12 months.
No Executive Sponsor
Pitfall: CRM is "IT's project." Fix: VP Sales or CRO sponsors the implementation, uses the dashboards publicly, and holds managers accountable for adoption.
Salesforce DevOps: CI/CD for CRM
Enterprise Salesforce implementations require DevOps practices — not just for custom code, but for all configuration: source control (all metadata — objects, fields, flows, page layouts — tracked in Git using Salesforce CLI or tools like Gearset/Copado), sandbox strategy (Developer sandbox for individual development, Partial Copy for integration testing, Full Copy for UAT — never develop in production), deployment pipeline (development sandbox → QA sandbox → staging sandbox → production, with automated tests at each stage), and release management (monthly release cadence for enhancements, hotfix process for urgent production issues). DevOps prevents: configuration drift between sandboxes and production (environments stay synchronized), deployment errors (manual deployments cause 30% of production issues), and audit gaps (every change tracked, attributed, and reversible). For enterprises with 200+ users and quarterly enhancement cycles, Salesforce DevOps isn't optional — it's the difference between controlled evolution and configuration chaos.
Salesforce and AI: Einstein Implementation
Salesforce Einstein adds AI capabilities to the CRM: Einstein Lead Scoring (ML model predicts which leads are most likely to convert — reps prioritize high-scoring leads), Einstein Opportunity Scoring (predicts close probability for each deal — managers focus coaching on at-risk opportunities), Einstein Activity Capture (automatically logs emails and meetings to CRM records — reps no longer manually log activities), and Einstein Copilot (conversational AI assistant within Salesforce — "show me my top opportunities closing this quarter" answered in natural language). Implementation best practices for Einstein: deploy Activity Capture first (zero user effort, immediate data enrichment), then Lead Scoring (requires 6 months of historical data), then Opportunity Scoring (requires consistent stage advancement data). Einstein value compounds with data quality — the cleaner the CRM data, the more accurate the AI predictions.
The Xylity Approach
We implement Salesforce with the 5 best practices — clean data migration, configuration-first design, least-privilege permissions, adoption-driven training, and governed integration. Our Salesforce architects, developers, and admins deliver implementations where reps adopt because the system helps them sell — achieving 80%+ daily active usage within 30 days of launch.
Go Deeper
Continue building your understanding with these related resources from our consulting practice.
Implement Salesforce Right the First Time
Five best practices — clean data, configuration-first, least privilege, adoption training, governed integration. Implementation that achieves 80%+ adoption.
Start Your Salesforce Implementation →