Hello everyone,

I recently faced a challenge with bulk record creation in Zoho CRM, particularly when dealing with large numbers of records. Processing a significant volume of data all at once can lead to performance issues or even errors. To overcome this, I implemented a method that processes records in manageable batches, ensuring smooth and efficient execution.

Below is an example code that demonstrates how to handle records in Zoho CRM using batch processing. This code is designed to process "Service A" and "Service B" records for active clients, creating corresponding entries in a "Tasks" module in batches of 100 records. This approach prevents potential API limitations and ensures all records are processed effectively.

2. week = zoho.currenttime.getWeekOfYear("Monday").toString();  // Get the current week of the year
3. info week;
4. 
   
5. clients = zoho.crm.getRecords("Accounts");  // Fetch all account records
6. serviceAList = list();  // Initialize an empty list for 'Service A' records
7. serviceBList = list();  // Initialize an empty list for 'Service B' records
8. batchSize = 100;  // Define the size of each batch
9. totalProcessed = 0;  // Track the total number of processed records
10. 
    
11. for each client in clients
12. {
13.     if(client.get("Status").contains("Active"))
14.     {
15.         // Check if the client has 'Service A'
16.         if(client.get("Services").contains("Service A"))
17.         {
18.             serviceAData = map();  // Create a map for storing 'Service A' data
19.             serviceAData.put("Week", week);
20.             serviceAData.put("Client", client.get("id"));
21.             serviceAData.put("Zone", client.get("Zone"));
22.             serviceAData.put("Neighborhood", client.get("Neighborhood"));
23.             serviceAData.put("Mobile", client.get("Mobile"));
24.             serviceAData.put("Service", ["Service A"]);  // Store the service as a JSON array
25.             serviceAData.put("Last_Service", client.get("Last_Service"));
26.             serviceAList.add(serviceAData);
27.         }
28. 
    
29.         // Check if the client has 'Service B'
30.         if(client.get("Services").contains("Service B"))
31.         {
32.             serviceBData = map();  // Create a map for storing 'Service B' data
33.             serviceBData.put("Week", week);
34.             serviceBData.put("Client", client.get("id"));
35.             serviceBData.put("Zone", client.get("Zone"));
36.             serviceBData.put("Neighborhood", client.get("Neighborhood"));
37.             serviceBData.put("Mobile", client.get("Mobile"));
38.             serviceBData.put("Service", ["Service B"]);  // Store the service as a JSON array
39.             serviceBData.put("Last_Service", client.get("Last_Service"));
40.             serviceBList.add(serviceBData);
41.         }
42.     }
43.     
44.     // Process batches of 100 records for 'Service A'
45.     if(serviceAList.size() >= batchSize)
46.     {
47.         responseServiceA = zoho.crm.bulkCreate("Tasks", serviceAList);
48.         info "Service A bulk creation - Batch " + ((totalProcessed / batchSize) + 1).toString();
49.         info responseServiceA;
50.         totalProcessed = totalProcessed + serviceAList.size();
51.         serviceAList.clear();  // Clear the list after processing
52.     }
53. 
    
54.     // Process batches of 100 records for 'Service B'
55.     if(serviceBList.size() >= batchSize)
56.     {
57.         responseServiceB = zoho.crm.bulkCreate("Tasks", serviceBList);
58.         info "Service B bulk creation - Batch " + ((totalProcessed / batchSize) + 1).toString();
59.         info responseServiceB;
60.         totalProcessed = totalProcessed + serviceBList.size();
61.         serviceBList.clear();  // Clear the list after processing
62.     }
63. }
64. 
    
65. // Process any remaining 'Service A' records
66. if(!serviceAList.isEmpty())
67. {
68.     responseServiceA = zoho.crm.bulkCreate("Tasks", serviceAList);
69.     info "Service A bulk creation - Final Batch";
70.     info responseServiceA;
71. }
72. 
    
73. // Process any remaining 'Service B' records
74. if(!serviceBList.isEmpty())
75. {
76.     responseServiceB = zoho.crm.bulkCreate("Tasks", serviceBList);
77.     info "Service B bulk creation - Final Batch";
78.     info responseServiceB;
79. }

How the Code Works

1. Initialization:

   • The script starts by retrieving the current week and all client records from the "Accounts" module. It also initializes empty lists for "Service A" and "Service B" records.

2. Filtering and Data Preparation:

   • For each client, the script checks if the client is active and then further checks for the specific services ("Service A" or "Service B"). If a service is found, relevant data is stored in a map and added to the appropriate list.

3. Batch Processing:

   • The code processes each list in batches of 100 records. Whenever a list reaches 100 records, the bulkCreate operation is triggered for the "Tasks" module, and the processed records are cleared from the list.

4. Final Processing:

   • After iterating through all clients, any remaining records in the lists (those that didn't complete a batch) are processed in a final batch.

5. Logging:

   • Throughout the process, informative messages are logged to track the batch processing, which helps in monitoring the script's execution.

Why This Approach?

• Performance Efficiency: By processing records in batches, the script avoids hitting API limits or causing performance degradation in Zoho CRM.
• Data Integrity: Ensures that no records are missed or duplicated during the bulk creation process.
• Scalability: This method is scalable and can handle both small and large datasets efficiently.

This approach has worked well for me, and I hope it helps others facing similar challenges. Feel free to ask any questions or share your experiences with similar tasks!