What does this page cover
This page outlines recommended best practices for building efficient and scalable applications in Zoho Creator. It covers guidelines for designing apps, structuring forms and fields, organizing data, writing optimized Deluge scripts, and using AI-powered assistance such as Zia effectively. Following these practices for your Creator applications helps ensure better performance, easier maintenance, and a smoother user experience.
1. Overview
Zoho Creator is a low-code platform that enables rapid application development, allowing businesses to build and deploy apps quickly. However, building them well requires a structured approach. Following standard best practices helps ensure your apps are scalable, secure, high-performing, and easy to maintain as your business grows.
By planning your app structure carefully, maintaining clean data relationships, optimizing workflows and scripts, and enforcing proper security standards, you can avoid common pitfalls and reduce long-term maintenance effort.
Whether you're a citizen developer creating your first app or an experienced developer managing complex solutions, these best practices will help you design efficient, reliable, and future-ready applications in Zoho Creator.
1.1 Why best practices matter
A business app is only as effective as the strategy behind it. When developed thoughtfully, Zoho Creator applications can:
- Improve operational efficiency by automating manual processes
- Provide stronger security and compliance through role-based access and audit trails
- Scale easily as business requirements grow
- Deliver real-time visibility into operations through metrics and dashboards
You can avoid common errors and reduce long-term maintenance efforts by:
- Planning your application structure carefully
- Designing for scalability from the beginning
- Maintaining clean and well-defined data relationships
- Optimizing workflows and Deluge scripts
- Enforcing strong security standards
2. Application design
2.1 Choose the right plan
Before we start creating an application in Zoho Creator, it's important to understand what the Creator platform can offer and what usage limits are applicable for each plan.
- As a rule of thumb, it's ideal to have at least 5 - 10 percent more limits than required. This will ensure that your application can scale in case there is a spike in user activity.
- Identify a pricing plan based on your organizational requirements including what type of users will be using the app. For example, if you require external customers to access your application, ensure you choose a plan that offers the customer portal feature.
2.2 Application structure and data
The following guidelines will help you structure your application effectively and ensure a strong foundation for scalability and maintainability.
- Before building the application, define the overall structure, design the data model including fields and relationships, identify fields that require encryption, and evaluate the pain points in the existing process.
- Document the application structure. This will make it easier to include changes later.
- Assign meaningful names for all components: forms, fields, reports, workflows, blueprints, pages, variables, functions, and permission sets.
- Use lookup fields to create relationships between the forms to avoid redundant data across forms.
- Set properties like Mandatory and No Duplicate values to fields to maintain data integrity.
- Avoid using subforms to store data that should exist as a standalone entity or be reused across multiple forms. In such cases, use a separate form with lookup relationships instead. This prevents unnecessary duplication, improves data normalization, and ensures that updates to shared data are reflected consistently across the application.
- Well-structured subforms help maintain clean data relationships, reduce redundancy, and improve overall app performance and maintainability.
- Delete components that are not required from the application.
- Specify delete behavior of records (what will happen to any related records when a particular record is deleted). For example, if an employee is deleted, what will happen to the tasks assigned to them.
- Avoid overlapping or conflicting workflows and trigger workflows only when necessary.
- Make and extensively test changes to the application in the development environment before publishing to stage and production.
- Use the scheduled app backup feature to create periodic backups.
- Ensure proper role-based access control, maintain data integrity through validations, and test thoroughly before deployment.
- To implement a data lifecycle strategy in Zoho Creator, you can automate the handling of inactive or outdated records using schedule workflows. This ensures that reports remain optimized while older records are either archived or deleted periodically.
2.3 Usability and user experience
Designing applications with usability and accessibility in mind ensures that users can easily understand, navigate, and interact with your app. The following guidelines help improve clarity, consistency, and overall user experience across different components of your application.
General
- Clear component names: Ensure that component names, such as names of forms, reports, pages, and so on, and their descriptions (if any) clearly convey their purpose. Additionally, provide descriptive labels and tooltips for form fields, making form submissions faster and easier.
- For example, instead of "Application Form," use something more specific like "Job Application Form" or "Membership Application Form" for the form name.
- A sample description in the above example could be "Fill out this form to apply for a position at our company. Provide your personal details, work experience, and qualifications."
- For the Name field, you could change it from "Name" to "Enter your full name."
- Keep language straightforward and inclusive: Avoid jargon, idioms, abbreviations, and uncommon phrases. Instead, use clear, straightforward language to enhance user understanding and accessibility.
- Consistency: Maintain consistent and clear labeling for page titles and navigation buttons across all components.
- Testing and user feedback: Periodically test your apps with users who have disabilities and incorporate their feedback into the app design process to create truly accessible user experiences.
- Documentation standards: Maintain internal documentation and clearly document workflows and automation logic for easier maintenance, future reference, and troubleshooting. Well-documented applications also make it easier to collaborate with other developers and share relevant information with support teams when issues arise.
- Localization: Use Zoho Creator’s multi-language translation support to make your applications accessible to a wider audience and enable seamless collaboration across organizational, geographical, and language barriers.
Forms
- Multi-column layouts can be used to break a form into smaller parts.
- Sections can be used to logically group fields based on context.
- Field size and the position of field labels can be set in which the field's input area is displayed when your users access your form from a web browser.
- Tooltips and help texts can be used to help the users understand the inputs required for a field.
- Success messages can be added to acknowledge form submissions.
- Email, SMS, and push notifications can also be configured to be sent to users on relevant actions.
- Appropriate success messages and alerts can be displayed to provide visual assistance.
Reports
- Contextual messages can be used to personalize the messages that appear in reports with appropriate content.
- Only the most important and relevant columns should be added to the Quick View of a report.
- Other information can be added to the Detail View and can be grouped logically using blocks.
- Freeze columns of a report to maintain the context of the record when scrolling through a report.
- Conditional formatting can be used to highlight specific records based on certain criteria.
- Frequent actions can be simplified using custom action buttons in addition to the existing system actions, which include edit, delete, duplicate, and view record. These buttons can be configured to have confirmation messages before being executed.
- Custom layouts and record templates can be used to further customize the appearance of records based on context.
- Use Canvas layout builder in Creator to design the detailed view layout of your records, corresponding to your business requirements.
Pages
- Pages can be used to create customized dashboards for your applications to get a comprehensive overview of the processes in the application, so it is not advisable to overload it with multiple components.
- Adding more than 10-15 components may increase the cognitive load for users.
- Multiple pages can be created based on context.
Application navigation
- Themes can be used to customize application navigation: top, left, grid navigation.
3. Using AI effectively
AI capabilities in Zoho Creator, powered by
Zia, can help accelerate app development, automate tasks, and generate scripts or components using natural language prompts. The following best practices help you use AI effectively, write better prompts, manage usage limits, and generate more accurate results.
Zoho GenAI is Zoho’s in house LLM and is available at no additional cost. When using Zoho GenAI, your data remains protected within Zoho’s ecosystem.
3.1 General practices for Zia
Note: Zoho GenAI features, such as script assistance, app and form creation, do not consume Creator AI calls and is free to use. Their usage is governed by the limits of the respective LLM provider configured with Zia.
- Keeping the following in mind when describing your business prompt:
- What problem do you want the app or form to solve?
- Who is this app intended to be used by?
- What data needs to be processed through the app?
- Don't include sensitive or confidential information in prompts while using AI features.
- Use everyday words to describe what your app or form should collect, track, list, and manage while entering your prompts, such as the following:
- “Create an asset management app for IT administrators to track company assets such as laptops, desktops, and mobile devices. The app should allow adding new assets, assigning assets to employees, tracking asset condition and location, recording maintenance history, and generating reports on asset status. It should include separate forms for assets, employees, asset assignments, and maintenance logs, along with a dashboard to monitor total assets, assigned vs. unassigned assets, and upcoming maintenance schedules.”
- This prompt works because it clearly defines who uses the app (IT administrators), what they need to accomplish (track assets, assign to employees, log maintenance, monitor status), what outputs matter (asset reports, assignment tracking, maintenance dashboard) ”
- AI-generated content may have mistakes. Ensure that the descriptional prompts provided are accurate and appropriate before using it.
- Attempting to create multiple apps in quick succession may exceed the rate limits of the selected LLM and result in errors.
- While creating scripts using Zia, you can specify the component name, link name, field name, or field link name along with the prompt to effectively utilize your created components for generating accurate scripts.
- For example, if you want to send an email to specific email addresses stored in a field of a form, it’s advisable to clearly mention the form name, the email field name, the criteria for selecting the emails, and the subject content in the prompt to generate a more precise and accurate script.
- An example of well-structured prompts: “Create a script for sending email notifications to the email addresses in the 'Email' field of the 'Orders' form to track the delivery of a product.”
- AI features are available to all paid Zoho Creator users, but each account has a defined limit on the number of AI calls based on its subscribed plan. Monitor and optimize AI usage to stay within your allocated quota and avoid interruptions.
Info: For more best practices to be followed while describing prompts effectively, refer
this page.3.2 Deluge Zia task
- The Zia task is subject to throttling based on the number of API calls made within a specific time period when using Zoho GenAI. Creator allows up to 7 simultaneous in-flight requests per user and 10 per organization. If this limit is exceeded, subsequent requests may be delayed or temporarily restricted until usage returns to normal.
- You can set the <temperature> parameter to the minimum for higher accuracy and fewer incorrect or fabricated outputs (hallucinations).
- You can also provide an additional message in the <context> parameter specifying the role to be assumed by the AI for improved clarity and more accurate responses.
4. Deluge
Deluge is the scripting language used in Zoho Creator to automate workflows, process data, and customize application behavior. Following these best practices can help you write cleaner, more efficient, and maintainable scripts while ensuring better performance and security.
4.1 Code structure and maintainability
- Keep the code modular and avoid heavy nesting of scripts.
- Scripts can be indented and comments can be added to them to provide a short overview of the logic and purpose.
- Split large code blocks into smaller, independent chunks to improve readability and maintainability.
- Variables can be given meaningful names to make the script easier to understand and maintain.
- Use functions to create reusable code blocks for frequently used or duplicated logic.
- Optimize loops by avoiding unnecessary iteration through large sets of records. Use control statements like break and continue to exit or skip iterations efficiently.
- You can use Zia Deluge assistance to modify or optimize the existing script if required.
- Use the aggregate record task effectively and fetch all records only when needed.
- Use the built-in functions wherever possible, as they are optimized for performance.
- Prefer using predefined Deluge functions such as equalsIgnoreCase, equals for comparison rather than "==" operator.
- Using indexed fields in criteria helps with fetching relevant records faster. Indexing is a back-end process, please contact us at support@zohocreator.com for assistance in enabling it.
4.3 Error handling and debugging
- Debugging statements like info can be used wherever applicable to identify and troubleshoot errors. Avoid logging sensitive or confidential data, and ensure that unnecessary info statements are removed or commented out.
- Use try-catch statements to handle exceptions in the code.
- Ensure all syntax errors in Deluge are resolved before saving, as scripts with errors cannot be saved or executed.
- Logical errors that occur due to poor programming practices and mistakes must be traced and fixed while testing. Any errors in Deluge scripting will only affect the application logic, and will not cause any vulnerabilities
4.4 Workflow and execution management
- Use an Else-If structure instead of multiple standalone If conditions, so the evaluation stops as soon as a matching condition is found.
- Tasks that do not need to run in real-time can be moved to Schedules or handled using the async task instead.
Note: The
Async task (development in progress) allows the scripts to run without having to wait for a response.
Track its release - Use the batch workflows feature to periodically, and automatically handle high-volume or repetitive operations on records. The records are processed based on the configured schedule, and you can break them down into smaller batches of up to 1000. This avoids looping through large sets of records at once, allows processing during non-business hours, and improves overall efficiency.
4.5 Security and API handling
- When using the invokeURL, invoke API, and any other Deluge integration tasks to make API calls, ensure that only the required response data is handled within your script.
- Make use of system variables like zoho.appuri and zoho.appname so that the application link name or the owner name changes do not affect your functionality. This is especially useful for Deluge scripts used inside HTML pages for embedding components.
- Ensure Deluge scripts are optimized to stay within the Deluge statement limits. These limits have been set to prevent accidental misuse of resources.
- Workflow execution throttle: Only 100 Deluge Workflows can be executed per IP address per minute.
4.7 Prefer configuration over scripting
- Use in-built features instead of scripting wherever possible. For example:
- Use bi-directional lookup through field properties instead of using scripts to reverse-assign values
- Set default values using the field properties instead of assigning them through scripts
- Use formula fields to perform calculations wherever possible instead of scripting
4.8 Deluge editor
- Syntax assist can be used to assign predefined values and facilitate error-free scripting.
- Versioning is available to track the various versions and code changes.
4.9 Scripts to be avoided
The following are a few scripts that can be avoided and alternatives for them.
Example 1:
❌ Fetching records, then iterating through each record like in the following script is not the most efficient method:
- fetchInvoices = Invoice_form[<criteria>];
- if(fetchInvoices.count() > 0)
- {
- for each invoice in fetchInvoices
- {
- <action>
- }
- }
✅ It is efficient to iterate over the records directly as part of the fetch operation:
- for each invoice in Invoice_form[<criteria>];
- {
- <action>
- }
Example 2:
❌ Iterating over records to retrieve values like in the following script:
- paymentList=List(); //creating a list variable
- for each invoice in PaymentAgainstInvoice[<criteria>] // iterating over fetched records
- {
- paymentList.add(invoice.ID); //extracting the ID and adding it to the list variable for each iteration
- }
✅ We can use built-in functions to perform the same operation efficiently:
- paymentList = PaymentAgainstInvoice[<criteria>].ID.getAll(); // all three above actions covered using a single statement
Example 3:
❌ Instead of iterating over records to fetch the count of records like in the below script:
- recordcount = 0
- fetchInvoices = Invoice_form[<criteria>];
- for each lineitemcount in fetchInvoices
- {
- recordcount = recordcount + 1;
- }
✅ Use aggregate functions instead:
- recordcount = Invoice_form[<criteria>].count(ID);
Example 4:
❌ Inserting records first, then modifying values of the insert record after a criteria check.
- billID = insert into Bill
- [
- Added_User=zoho.loginuser
- Total_Price=Total_Price
- Bill_Status=Bill_Status
- ];
- fetchBill = Bill[ID == billID];
- if(patient_Type == "Free")
- {
- fetchBill.Total_Price=0;
- fetchBill.Bill_Status="Closed";
- }
✅ Instead, we can perform the check before inserting the data:
- if(patient_Type == "Free")
- {
- Total_Price=0;
- Bill_Status="Closed";
- }
- billID = insert into Bill
- [
- Added_User=zoho.loginuser
- Total_Price=Total_Price
- Bill_Status=Bill_Status
- ];
Example 5:
❌ Using APIs to update records and trigger post update logic.
- rec = Form[ID = <record_ID>];
- rec.Single_line = <value>;
- updateapi = zoho.creator.updateRecord(<owner_name>, <app_link_name>, <report_link_name>, rec.ID, <new_input_values>, <other_api_params>, <connection_link_name>);
✅ Instead, we can use the update record deluge task and trigger the post-update logic using a function:
- rec = Form[ID = <record_ID>];
- rec.Single_line = <value>;
- rec.Number = <value>;
- functionscript = thisapp.<function_with_on_success_code>(int rec.ID);
5. Security
Security is a critical aspect of application development. Implementing proper access controls, protecting sensitive data, and reviewing automation logic can help ensure that your Zoho Creator applications remain secure and compliant. The following best practices outline how to safeguard users, data, and application components.
5.1 Users and permissions
- Only the required users should be added to the application, and only the necessary modules should be shared.
- Users or developers who no longer require access to the application should be removed.
- When more than one user is building the app, add the required users as developers instead of sharing the admin credentials.
- Access to APIs, as well as PII (Personally Identifiable Information) and ePHI (Electronic Protected Health Information) data can be given to the necessary permission sets alone.
- Export, delete, view all, and bulk edit permissions must be limited.
- Permission sets that are not required for users and customers can be deleted.
- Fields that collect or contain PII and ePHI data should be encrypted.
- Sensitive information can be masked in reports wherever applicable.
- Filters and criteria can be added to reports to ensure only the required information is displayed to users.
- Any sensitive information that is stored can be deleted when it is no longer required.
- Confirmation messages can be associated with custom action buttons.
- It is not advisable to collect or store sensitive information like SSNs or passwords. If collected, the purpose should be stated in the form.
- It is best to avoid storing API credentials in the application.
- Help text or tooltips can be associated with fields to elaborate on the reason for collecting the data.
- Note fields can be added in forms to specify the purpose of data collection.
- It is advisable to deactivate published forms when public access is no longer required.
- Decision box can be used to obtain consent for data collection.
- When collecting details on user location and IP addresses by enabling them in form properties, it is advisable to inform them of this and obtain their consent. IP address can also be encrypted.
- Actions in reports like Add, Delete, and Duplicate must be reviewed, and can be removed if not required.
- The history of changes made to records can also be tracked using the Audit trail feature.
5.3 Workflows and scripting
- Optimize workflows and Deluge scripts to avoid unnecessary complexity, and automate only where it adds real value.
- Use comments wherever possible.
- Input validations should be done for fields wherever possible.
- Any hyperlinks used in the application should be verified.
- Content in SMS, Email, and push notification tasks should be reviewed.
- OAuth-based authentication should be used wherever possible when invoking APIs.
- Business logic like functions and schedule workflows can be executed inside the workflow builder itself for testing purposes before being incorporated in the main flow.
5.4 Pages
- JavaScript codes used inside widgets must be reviewed.
- For pages that work based on page variables, make sure to include null checks to prevent the page from displaying errors or irrelevant data.
6. Mobile apps
Zoho Creator applications can be accessed through mobile devices, enabling users to perform tasks and manage data on the go. The following best practices help optimize your apps for mobile usage by improving navigation, presentation, and overall user experience.
- The actions and the events during which the actions are triggered like tap of a record, swipe left, and swipe right can be determined and changed.
- Columns in the quick view and detail view of a report can be set according to the app context.
- Custom logo can be uploaded to the applications.
- Applications can be rebranded and published separately for users and customers.
- GDPR readiness
- Best practices for platform performance
- Creator help resources