It is the second Monday after the new CRM went live. The VP of Sales opens the pipeline dashboard before the weekly forecast call and sees that the commit number is 40% below the figure the regional managers sent on Friday. On the call, one manager explains that a third of his team’s deals “are not in the system”, although they are; they were migrated under the name of a rep who left in the summer. Another says her team logs only what they must, because every meeting booked in Outlook now appears twice and every inbound lead triggers three alerts. By the afternoon, a file called Q4_pipeline_FINAL_v2.xlsx is back in the VP’s inbox. The CRM works. Sales has already left it.

On paper, the rollout was well tested. The implementation partner ran several hundred test cases, nearly all of them passed, and the acceptance document was signed on schedule. What nobody tested was whether a sales rep logging in at eight on Monday morning would find their own accounts, their own pipeline and their own meetings exactly as they knew them the week before.

This article is for QA leads, Sales Ops and revenue operations teams, and project managers running a CRM implementation. Its argument is simple and, for many teams, uncomfortable: CRM rollouts do not fail on missing features; they fail on lost trust in the data during the first few weeks. That is why the go-live decision should rest mainly on data reconciliation and record visibility tests, carried out by sales reps themselves on migrated data, rather than on the percentage of test cases passed. Below we cover what to check in seven areas and how to structure the go/no-go criteria.

Why do sales teams go back to spreadsheets after a CRM has passed testing?

Because the testing asked whether the system works, while sales reps ask whether the system is true. Those are different questions. A test case such as “create an opportunity and move it to the negotiation stage” passes in any correctly configured CRM. It tells you nothing about whether a deal a rep has worked for three months still has the right amount, the right owner and its email history after migration.

A spreadsheet has one advantage over a new system: the rep trusts it, because they built it. Every inconsistency in the CRM during the first days, such as a missing account, a duplicated meeting, a colleague’s deal showing up in their list or their own deal missing from it, becomes evidence that the system cannot be believed. After a few of those moments a shadow appears: a spreadsheet kept in parallel, which the rep actually works from, while the CRM gets updated just before the pipeline review. From then on CRM reports stop reflecting reality, and the problem compounds because managers return to spreadsheets too.

The reasons reps go back to spreadsheets fall into five categories, and each of them can be tested before go-live:

  • data is incomplete, outdated, duplicated or assigned to the wrong people;
  • visibility is wrong: reps cannot see their own records or can see other people’s;
  • integrations with email, calendar, ERP and telephony lag, duplicate entries or lose data;
  • automations flood people with notifications or route leads in ways the team never agreed to;
  • performance of an account list or a report on a phone in the field is so poor that the spreadsheet is faster.

Notice that functionality in the narrow sense, whether a button creates a record, only appears on this list indirectly. That does not make functional tests unnecessary. It means they are not sufficient for a go-live decision.

What are we actually testing in a CRM implementation if the platform is off the shelf?

On a commercial platform such as Salesforce, HubSpot or Microsoft Dynamics 365, the vendor tests the product’s own code. You are not testing whether the contact form writes to the database. You are testing what your company and your implementation partner added to the platform and what they connected to it. With a custom-built CRM you also test all the code, but the rest of the list stays the same. We compared the two routes in our article on when custom CRM development pays off; here we assume the decision has been made and the system is approaching launch.

CRM testing usually covers six layers:

  1. Configuration: objects, fields, picklists, pipeline stages, validation rules, page layouts, list views.
  2. Customizations: custom code, plug-ins, scripts, UI components, calculated fields.
  3. Security model: roles, profiles, permission sets, teams, business units, sharing rules, field-level security.
  4. Data: migration from the old system, spreadsheets and mailboxes, deduplication rules, reference data.
  5. Integrations: email, calendar, ERP, telephony, web forms, the marketing platform, e-signature, partner systems.
  6. Processes and automations: lead routing, escalations, reminders, discount approvals, quote generation, notifications.

On top of that list sits a requirement that is easy to forget: everything has to be tested with data and roles that are as close to production as possible. A test case run by an administrator on five synthetic records will not reveal permission problems (administrators see everything), performance problems (five records always load quickly) or data quality problems (synthetic records are perfectly clean).

A second point concerns upgrades. SaaS platforms ship several releases a year, and each one can change how your customizations behave. The test suite you build before go-live is therefore not a one-off cost. It is the start of a regression suite that will run after every platform release and every configuration change. It pays to write test cases from the start so that someone else can run and maintain them; we cover how to write test scenarios and test cases for handover separately.

How do you verify the data migration before the first sales rep sees it?

Migration is the most important area of CRM testing, because data, not screens, decides whether people trust the system. The typical mistake is to check migration with spot checks: someone opens twenty random accounts and compares them with the old system. Spot checks catch errors that affect every record. They do not catch errors that affect one percent of records, and those are the ones that later break reports.

What you need instead is reconciliation: comparing aggregate values between the source and the CRM and explaining every difference. A minimum set of reconciliations looks like this:

  • record counts for every object type (accounts, contacts, leads, opportunities, activities, products, price books) in the source and in the CRM;
  • total value of open opportunities by stage, owner and region, because this is the number a sales manager will compare with their spreadsheet on day one;
  • number of open tasks and scheduled meetings for the coming weeks, because a lost meeting is the fastest way to lose a rep’s trust;
  • distribution of record owners, including records owned by people who have left the company;
  • number of duplicates under the agreed matching rule (for example the same company registration or tax number, the same email domain, the same contact email address);
  • rejected records, with the reason for each.

Every difference must have one of three explanations: a rejected record with a logged reason, a record merged as a duplicate, or data deliberately left behind by a business decision. A difference without an explanation is a defect, even if it concerns a handful of records.

Duplicates deserve their own test, because they come from two directions. The first is migration: the same companies entered in different spreadsheets by different reps. The second is integrations after go-live: web forms, trade show imports, email sync. Platforms have duplicate detection, but it must be configured and tested. Microsoft’s documentation for Dynamics 365, for example, states that the default duplicate detection rules cover accounts and contacts but not other record types, and that you can publish at most five rules for the same base record type at a time. Your test should therefore check not only that the rule fires when a user creates a record by hand, but also during imports and for records created by integrations.

History is the third layer. A rep who opens an account wants to see recent conversations, quotes and notes. If the migration moves only current state without activities, the acceptance test must make that visible and the business must accept it explicitly. It is better for a rep to hear before go-live that history older than two years will live in an archive than to discover it during a customer call.

Migration is also where data protection rules apply. For organisations processing personal data of people in the EU, Article 5(1) of the GDPR requires, among other things, that personal data be limited to what is necessary for the purpose, accurate and kept up to date, and stored for no longer than necessary. For testing that means two concrete checks: that the CRM did not receive contacts the company should no longer hold (for example people who withdrew marketing consent), and that consent records and the legal basis for processing travelled with the contacts. Cleaning the data before migration is separate work; we look at which parts of it, such as profiling and data quality, can be outsourced in our article on data management services.

The final step of migration testing belongs to the reps themselves: each one is asked to check their own account list and pipeline and report what is missing or wrong. It takes perhaps fifteen minutes per person and is the most effective test you can run, because nobody knows that data better.

How do you test permissions and record visibility?

CRM permissions are about much more than who can log in. Salesforce’s Trailhead training describes four levels of data access: the organisation (who can log in and when), objects (what a user can do with a type of record), fields (which fields they can see) and records (which individual records they can see). At record level further mechanisms apply: organisation-wide defaults, a role hierarchy that gives managers access to their reports’ records, sharing rules and manual sharing of individual records. Microsoft Dataverse, which underpins Dynamics 365, relies on business units, security roles with access levels (user, business unit, parent-child business unit, organisation), teams and column-level security.

The Dataverse documentation spells out a principle that matters a great deal to a tester: privileges are cumulative. A user receives the broadest access granted by all their roles and team memberships. If one role grants organisation-level read access to all contacts, another role cannot hide a specific contact from that user. That is why permission defects rarely come from a single misconfigured role. They come from combinations: a rep who also sits on the key accounts team suddenly sees the pipeline for the entire region.

Permissions are tested with a matrix. Rows are business roles, not technical profile names: field rep, inside sales rep, regional manager, sales director, customer service, finance, marketing, channel partner. Columns are record types and operations: read, edit, delete, export, change owner and visibility of sensitive fields (margin, discount, personal data). You write the expected result in every cell, and the test consists of logging in as a test user with that role and checking it.

Three kinds of cases belong in the matrix explicitly:

  • negative tests: a rep in the East region cannot see West region deals, a channel partner cannot see margins, marketing cannot export the full contact database;
  • organisational changes: a rep moves to another territory, a manager leaves, an account changes owner. What happens to the records, the open tasks and the access?
  • indirect paths: reports, global search, exports, the mobile app, email notifications and integrations. A record hidden in a list view is sometimes visible in a report or in the body of an automated alert.

Permissions are the one area where defects damage trust in both directions. A rep who cannot see their own accounts stops believing the system. A rep who can see a colleague’s commission stops believing their own data is safe. You will see the first defect in support tickets. You may only hear about the second one by accident, which is why negative tests have to be in the test plan rather than left to hope.

For a QA team this is also a compliance matter. Article 32(1)(d) of the GDPR requires “a process for regularly testing, assessing and evaluating the effectiveness of technical and organisational measures for ensuring the security of the processing”. A documented permission matrix and its test results are good evidence of such a process if you ever need to show one.

How do you test email and calendar integration?

Email and calendar sync is the feature reps feel most often, because it touches every working day. It is also where expectations most often diverge from how the platform actually behaves.

An example from Microsoft’s documentation: server-side synchronization in Dynamics 365 runs on a schedule for each mailbox. After an incoming email cycle completes, the mailbox waits five minutes before the next one; after a cycle for appointments, contacts and tasks, it waits between five and twelve minutes. Microsoft states plainly that there is no defined SLA for the duration of a synchronization cycle, because it depends on the email provider, the number of items, connection throttling, attachments and customizations. For a tester this is important: if reps expect a meeting added in Outlook to appear in the CRM instantly, the test has to surface that gap and the training has to explain it before it gets reported as a bug.

The same documentation sets another rule: a mailbox can be mapped to only one user, and a user to only one mailbox. An executive assistant who manages three directors’ calendars is a test scenario you need to think through before go-live.

Build the email and calendar scenarios around the problems reps will notice immediately:

  • duplicate meetings: a meeting created in the CRM, synced to the calendar, moved in the calendar and synced back. How many records exist afterwards, and which one is current?
  • time zones: a meeting with a customer in another time zone, and a daylight saving change in the middle of a recurring series; for US and European teams the clocks change on different weekends, which is a classic edge case;
  • private appointments: does a rep’s dentist appointment end up in the CRM as an activity their manager can see?
  • linking emails to records: does a customer email land on the right account when the contact has two addresses, or when the same address exists on two accounts (for example within a group of companies)?
  • outgoing email: does a quote sent from the CRM appear in the rep’s sent items, and does the customer’s reply come back to the same record?
  • attachments and size: what happens to a large attachment, and does it push you towards the platform’s storage limits?

Test sync on real test mailboxes with the same email provider your company uses, not on a simulation. Many problems stem from mail server configuration, security policies and application consent settings that a simulation will not reproduce.

How do you test ERP, telephony and web form integrations?

Integrations with systems outside the CRM share one property: the data has two potential owners. Before you start testing, check that for every field there is a written decision on which system is the source of truth. If there is not, the test has no expected result, and every data conflict will be resolved ad hoc by whoever wrote the integration.

ERP. A typical flow covers customers and their billing data, products and price lists, orders, invoices, accounts receivable balances and credit limits. For each of them you test:

  • the direction and timing of sync (real time, every fifteen minutes, nightly);
  • conflicts: the same customer changed in both systems before sync runs;
  • retries: the same message sent twice after a network error must not create two orders;
  • failure on the other side: the ERP is unavailable during month-end close. Does the data wait in a queue or disappear, and does anyone get alerted?
  • records the ERP will reject: a missing tax ID, an invalid country code, a discontinued product.

Reps rarely see an integration failure directly. They see its consequence: a customer on credit hold who just received a quote, or a price on the quote that differs from the invoice. Every such case is an argument for “I’ll check the ERP and keep a note in my spreadsheet”.

API limits. Integrations run within the platform’s limits, and functional tests on a few dozen records will not reveal them. HubSpot’s developer documentation lists, for private apps, a burst limit of 100 requests per 10 seconds and 250,000 requests per day on Free and Starter, 190 per 10 seconds and 625,000 per day on Professional, and 190 per 10 seconds and 1,000,000 per day on Enterprise. Other platforms have their own limits. An integration test should check what happens when the limit is reached: does the integration back off and retry, or does it lose data? The riskiest moments are the migration and the first full sync, when the whole database moves in one go.

Telephony. Integration with a phone system or contact centre platform usually covers click-to-call from a record, caller recognition on inbound calls and automatic call logging as an activity. The most common problems come from number formats: “(415) 555-0100”, “+14155550100” and “001 415 555 0100” are three different numbers to an integration, and a European team adds national formats with and without the leading zero. The test should check caller recognition for every format present in the migrated data, and the migration should normalise numbers to a single international format. Add missed, forwarded and withheld-number calls, and check that call recordings, if you keep them, carry the right permissions.

Web forms and lead sources. The website contact form, campaign landing pages, trade show list imports, live chat. You test field completeness, lead source (without it, marketing cannot measure campaign performance), deduplication against existing contacts, consent capture and the time from form submission to the lead being assigned to a rep.

Pricing those integrations is a separate conversation; if you are still scoping them, read how to price an API integration project across ERP, CRM and payments. From a testing point of view, the key is that every flow has a documented failure scenario, not just a happy path, because integrations erode trust more through how they fail than through how they work.

How do you test automations and notifications without flooding inboxes?

Automations are where a CRM can be correct and unbearable at the same time. Each rule on its own does exactly what the requirements say. Together they produce a stream of alerts that reps start filtering into a folder nobody reads within a week.

It helps to split automation testing into three levels.

A single rule. Does lead routing follow what the team agreed: by territory, industry, company size, round robin? What happens when the rep the rule assigns to is on vacation or has left the company? Does the 48-hour no-contact escalation count business days or calendar days, and does it respect public holidays in each country you sell into?

Interactions between rules. One rule changes an opportunity’s status, which triggers a second that updates a field on the account, which triggers a third that sends a notification. The most dangerous patterns are loops: two rules that update each other’s fields, or an ERP integration that fires a “record changed” automation after every sync. You test this by running full processes from lead to order and counting how many events and notifications were generated along the way.

Volume. Importing a thousand contacts from a trade show means a thousand new records. If each one triggers a welcome rule and an alert to the owner, a rep receives hundreds of messages within minutes, and customers receive emails that were meant to go out only after qualification. The same applies to migration: if automations are active while data loads, a ten-year customer receives a “welcome aboard” email. The test should check both that automations are switched off during migration and bulk imports and that they are switched back on afterwards.

A simple test that catches most notification problems: for one day of acceptance testing, collect every notification each participant received, and at the end of the day ask which of them were useful. If the answer is “fewer than half”, you have configuration work to do before the system reaches the whole sales organisation.

How do you performance-test a CRM when it is not an online store?

A CRM does not face thousands of anonymous users during a flash sale, so performance often drops off the test plan. That is a mistake, because CRM performance problems have a different shape: they depend less on concurrent users and more on data volume and configuration complexity.

A slow CRM usually means one of these:

  • list views and search on the full database rather than test data: a “my accounts” view for a rep with several thousand accounts, or a search on part of a company name;
  • reports and dashboards, especially those calculated live across the full opportunity history and opened by every manager on Monday morning before the forecast call;
  • record pages with many related lists, calculated fields and components that query the ERP every time the page opens;
  • the mobile app in the field, on weak coverage, with offline sync;
  • bulk operations: reassigning several hundred records after a territory change, imports, price book updates.

CRM performance testing therefore happens mainly in an environment with the full migrated data volume and every customization in place, not in an empty sandbox. Before you measure anything, agree with the business on thresholds that make sense for the work: for example, that opening an account record on an office laptop should take no more than a few seconds, and that the account list on a phone should load in the time a rep spends waiting in a customer’s lobby. These are illustrative thresholds, not a standard; what matters is that they are written down before the test rather than settled after it.

Microsoft’s documentation on email sync highlights another dependency: long-running synchronous customizations in the email delivery flow reduce sync throughput. It illustrates a general rule: every plug-in or rule that runs when a record is saved adds time to every operation, including those performed by integrations. If you need outside help, performance testing as a service has its own scope, timeline and price, which we describe separately.

How do you run user acceptance testing with sales reps so it is not just a demo?

User acceptance testing on CRM projects often turns into a presentation: the implementation team demonstrates features, reps nod, the sign-off document gets signed. That kind of UAT finds nothing, because the reps were not doing their own work; they were watching someone else’s.

UAT that protects against the drift back to spreadsheets has four features.

Reps test, not their proxies. You need people from every role: field reps, inside sales, managers, customer service, someone from finance. Not only the enthusiasts and not only the people who sat on the project team. The most valuable feedback usually comes from the sceptics, because they are the first who will reopen the spreadsheet.

They test on their own data. Each participant works on migrated data, logged in as themselves, with their target role. The first task is to check their own account list and pipeline. Process scenarios come after that.

Scenarios describe a working week, not features. Instead of “create an opportunity”, the scenario reads: “On Monday morning review your tasks for the week, prepare for the meeting with customer X, after the meeting log a note and the next step, send a quote with a discount that needs approval, check that your manager approved it and update your forecast.” A scenario like that runs through data, permissions, integrations, automations and performance at once. Good acceptance scenarios have clear acceptance criteria, so that “works” and “does not work” are not a matter of mood.

Feedback is treated as defects. “This is slow” or “I can’t find where this is” is a report, not an opinion. It may end in a configuration fix, a training change or a deliberate decision to leave it as it is, but it needs an owner and an answer before go-live.

UAT planning, preparing data in line with data protection rules and the sign-off itself deserve their own article; we collected them in our UAT planning checklist. For a CRM, add one item to it: a final round on data from the last trial migration, run with the same participants as the first. If reps in the second round find the same problems as in the first, the system is not ready, regardless of how many tickets have been closed.

Which go/no-go criteria should decide a CRM launch?

The go-live decision should rest on criteria written down before testing starts, not negotiated in the final week. The table below sets out criteria that follow the argument of this article: data and visibility carry the most weight, and the pass rate of test cases is one signal among many. The thresholds in the last column are examples to agree with the business, not an industry standard.

AreaWhat you checkWho signs offExample threshold to agree
Data migrationReconciliation of record counts, pipeline value, open tasks and owners between source and CRMQA lead and Sales OpsEvery difference explained and accepted by the business
Reps’ own dataEvery rep has checked their account list and pipelineRegional managers100% of reps confirmed, reported issues closed
DuplicatesDuplicate count under the matching rule after migration and after a test importSales OpsAt or below the agreed limit, rules active for imports and integrations
PermissionsRole and operation matrix, including negative tests, reports and exportsQA lead and data protection officerNo open defects in negative tests
Email and calendarDuplicate meetings, time zones, private appointments, email-to-record linkingQA lead, pilot usersNo duplicates; sync delays explained in training
ERP and telephonyDirection, conflicts, retries, downstream failures, number formatsIntegration teamEvery failure scenario has a documented and verified behaviour
AutomationsFull lead-to-order processes, notifications per participant, automations off during importsSales OpsUAT participants rate most notifications as useful
PerformanceLists, reports, record pages and the mobile app at full data volumeQA leadAgreed response times met for key screens
UATWorking-week scenarios run by every role over two roundsBusiness ownerNo open blocking defects; second round shows no repeats from the first
Rollback planWhat happens if launch fails: data, integrations, communicationProject managerPlan rehearsed in a test environment

Two criteria in this table deserve a closer look. The first is sign-off by every rep. It looks excessive, but it is the only way to spread responsibility for data accuracy across the people who know that data. A rep who confirmed their pipeline before go-live will not say a week later that “the system is full of rubbish”. The second is the rollback plan. It is rarely used, but its absence changes the dynamics of the decision: if there is no way back, every problem found in the last week gets labelled “fix after launch”.

How do you measure adoption after go-live and when should you act?

CRM testing does not end on launch day. The first weeks after go-live are when trust in the system either settles or the first shadow spreadsheets appear. Plan a hypercare period and track adoption signals from day one.

Logins are a weak indicator, because a rep can log in daily just to enter the minimum. Better signals are:

  • opportunity freshness: the share of open opportunities updated in the last seven days;
  • activities: meetings, calls and notes logged per rep, compared with how many meetings reps actually have in their calendars;
  • forecast consistency: the gap between the CRM forecast and what managers report in pipeline reviews;
  • exports: how often account and opportunity lists are exported to spreadsheets, because a regular export is often where the shadow begins;
  • tickets: the number and type of user reports, split into data, permissions, integrations, automations, performance and usability.

Treat each signal as a test result, not as a discipline problem. If activity drops in one region, the cause may be a calendar sync issue with a particular email setup rather than a lazy team. If exports rise, ask what reps are missing in the views and reports. The answer often points to a missing field or filter that can be added in a few hours.

Staff the hypercare period with people who know both the configuration and the test suite. Every fix made after go-live needs the relevant part of the regression suite to run, because the first weeks bring the most changes, and it is easy for a permission fix in one territory to open access in another.

Who should test a CRM: the implementation partner, your own team or independent QA?

Each of them tests something different, and none can replace the others.

The implementation partner tests what it built: configuration, customizations and integrations against the specification. It knows the platform best but has a natural conflict of interest: its tests show that it delivered the contracted scope. It rarely looks for problems in places the specification did not describe, such as permission combinations, automation interactions or integration behaviour under failure.

Your own team, meaning Sales Ops, sales reps and administrators, brings knowledge of the data and processes that nobody else has. Without it you cannot reconcile the migration or run credible UAT. But it usually lacks experience in test design, permission matrices and performance testing, and it has no spare time, because it is busy selling.

An independent QA team designs the test strategy, builds the permission matrix and integration failure scenarios, prepares and facilitates UAT, reports results to the business owner and holds the line on the go/no-go criteria. Its value is that it is accountable for neither the build nor the sales number, so it can say “we are not ready” when the evidence says so.

In practice the split that works best gives the implementation partner unit and functional testing of its scope, your own team data reconciliation and UAT, and independent QA the strategy, the cross-cutting tests (permissions, integrations, automations, performance) and a criteria-based recommendation. If that third element is missing, someone has to take on its duties, usually the client-side project manager, and the plan should say so.

ARDURA provides software testing services, including functional testing, API and integration testing, performance testing, regression testing and UAT support; QA rates range from about EUR 130 to 335 per day for manual testers and EUR 165 to 465 per day for automation engineers. If you are starting from scratch, a separate service covers QA strategy and test management: a fixed-scope package that takes two weeks and starts from EUR 3,700, covering a risk-based test strategy, selection and setup of a test management tool, and handover to your team.

What are the key takeaways before your CRM goes live?

A CRM rollout does not lose to missing features. It loses to the first week in which a rep cannot find their account, sees a duplicated meeting or receives thirty pointless alerts and reopens the spreadsheet they know. Testing meant to prevent that has to measure trust in the data, not just functional correctness.

Remember seven things:

  1. Reconcile the migration instead of spot-checking it. Record counts, pipeline value, open tasks and owners must match the source, and every difference needs an explanation.
  2. Let every rep check their own data before go-live. It takes a few minutes per person and is the most effective test in the whole project.
  3. Test permissions with a matrix, including negative tests. Access is cumulative, so defects come from combinations of roles, not from a single role.
  4. Write a failure scenario for every integration. Conflicts, retries, downstream outages and API limits are either found before go-live or reported by reps after it.
  5. Count the notifications. Automations can be correct one by one and unbearable together; switch them off during migration and imports.
  6. Test performance at full data volume, with every customization in place, on a laptop and on a phone in the field.
  7. Agree go/no-go criteria before testing and track adoption from day one, treating every sign of a return to spreadsheets as a defect report.

If you are preparing a CRM launch and want someone independent of the implementation partner to design the tests, run the data reconciliation and facilitate UAT with your sales team, see how we approach software testing, or book a call. We will start with your rollout’s risk list and the criteria your sales organisation must meet before it moves to the new system.