1. Choose the right query type

• Module-type queries work best when you need a quick fetch from a single module. For straightforward data retrieval, a simple Module query is often faster and easier to manage.
  
• COQL-type queries follow the SQL-like language model and allow you to filter, sort, and join data more deeply.
  
• REST API-type queries enable Zoho CRM to retrieve real-time data from external systems via GET requests, allowing you to display externally computed or stored information within CRM views.
  

2. Name your queries clearly and consistently

• Avoid query names like Get_Contacts_Test or Canvas_Query_1 as they become confusing over time.
  
• Instead, use names that reflect what the query actually returns and where it is used. For example, Open_Deals_By_Owner_For_Canvas, Upcoming_Activities_By_Account. This helps you or your team find and reuse queries faster.
  

3. Use nested lookups selectively

• Use nested lookups in COQL-type queries selectively to balance power and performance. Nested lookups in COQL help in reducing the number of API calls by fetching related records in the same query, but use only the lookup fields that are truly necessary when using queries in UI components or optimizing for speed.
  
• Limit yourself to the lookup fields your UI or logic actually needs. For example, do not retrieve Account.Owner.Territory.Name if you're only displaying the account name.
  
• If multiple nested fields are needed for display, consider flattening the data using serializers to keep the query clean and efficient.
  

4. Limit returned record count for list views

• For queries used in related lists or Canvas, fetch only the required number of records/rows to keep your UI focused and efficient.
  
• For example, in a Canvas View, it is best to fetch only the immediately relevant records like the latest notes, top deals, most recent activities etc,. This ensures that the data is concise, relevant, loads the UI quickly, and remains user-friendly across devices.
  

5. Use Variables to keep queries reusable

• Hard-coding values like record IDs or user names limits reusability.
  
• Instead, define variables like {{User_ID}}, {{Record_ID}}, or {{Account_ID}}, and pass them dynamically. This means you can use the same query across multiple records, users, or components.
  

6. Blend static and dynamic filters

• Not all values need to be variables.
  
• If a certain condition will always be true like 'Status = Open', hard-code it. But for user-specific and record-specific values, create variables. This mix of static and dynamic variables in your filters makes your query both specific and versatile.
  

7. Avoid fetching unnecessary fields

• Avoid selecting all fields by default. Fetching unnecessary fields increases response size and adds clutter.
  
• Limiting the field selection makes the query easier to maintain, especially when working with nested lookups and across modules.
  
• Smaller and focused responses are easier to format and bind in the UI components leading to better data handling.
  
• Even though CRM handles larger data well, brevity in the query leads to faster rendering and, ultimately, a better user experience.
  

8. Use serializer to format your output

• Don’t pass raw API data directly into your UI. Use serializers to clean, rename, and shape your response.
  
• For example, merge first and last names into a single full name field in the serializer.
  
• This keeps the UI logic clean and puts formatting responsibility where it belongs—inside the query layer.
  

9. Customize the schema after your query

• Zoho CRM auto-generates a schema for your query output, but it may not reflect exactly how they're used in your interface.
  
• Rename keys to reflect how they’re used in your interface, remove unused fields, and flatten nested objects where possible.
  
• A clean and relevant schema makes data binding faster and reduces errors.
  

10. Understand your return type: Map vs Table

• Use a Map when returning a single record (like in a summary view).
  
• Use a Table when returning a list (like in a data grid or related list).
  
• Using the wrong type and misalignment can break your Canvas component, show blank widgets or broken layouts.
  

11. Map queries to the right components

• In Canvas, use queries to control what each widget displays.
  
• In Kiosk, tie queries to user flows or form submissions.
  
• In Custom Related Lists, pass record-level variables like {{Deals.Deal_ID}} for contextual filtering.
  

12. Use record ID-based filters properly

• Filtering with ID variables is common and useful, but too many queries filtered by IDs can lead to firing many API calls and consuming more API credits.
  
• Reuse queries and batch where possible.
  

13. Standardize REST API outputs with the 'crmAPIResponse' object

• REST API type queries give you flexibility, but may not return the response in the format that your UI expects.
  
• Use the 'crmAPIResponse' object to standardize the output, extract what you need, and define fallback values in case something is missing.
  
• This control in the output structure allows you to fit the output to your schema and maintain consistency across your queries.
  

14. Use Queries to supercharge related lists

• Queries can now power custom Related Lists where you are not limited to predefined module relationships.
  
• Use parent record variables to filter child records, apply sorting logic, and format fields for a clean display.
  
• Keep the row count reasonable for performance and readability.
  

15. Always test and monitor

• Try the query to preview data, validate filters, and confirm variable substitution. It’s far easier to fix errors here than once the query is embedded in a Canvas view or live layout. Include user role and profile tests where needed.
  
• Check how schema or field updates affect the output.
  
• Log serializer issues or failed REST calls during development.