🧩 Dynamic SuiteScript Configuration Framework (Parameter-Driven Logic)

Introduction

Have you ever duplicated a script just to change a form ID, saved search, or customer type?
That’s a common pain point in NetSuite development — but it’s completely avoidable.

By building a Dynamic Configuration Framework, you can make your SuiteScripts flexible, reusable, and environment-agnostic.
This framework uses script parameters, custom records, and configuration lookups to drive logic dynamically — no more hardcoding IDs or constants.

💡 Why Build a Configuration Framework?

✅ Goal: One script, multiple uses — easy to deploy, configure, and audit.

🧱 Step 1: Create a Configuration Custom Record

Name: Script Configuration
ID: customrecord_script_config

⚙️ Step 2: Create a Utility Module to Fetch Configuration

/**
 * @NApiVersion 2.1
 * @NModuleScope Public
 */
define(['N/search'], (search) => {

    function getConfig(scriptKey, subsidiaryId) {
        const configSearch = search.create({
            type: 'customrecord_script_config',
            filters: [
                ['custrecord_script_key', 'is', scriptKey],
                'AND', ['custrecord_subsidiary', 'anyof', subsidiaryId],
                'AND', ['custrecord_config_status', 'is', 'Active']
            ],
            columns: ['custrecord_search_id', 'custrecord_form_id', 'custrecord_account_id']
        });

        const result = configSearch.run().getRange({ start: 0, end: 1 })[0];
        if (!result) return null;

        return {
            searchId: result.getValue('custrecord_search_id'),
            formId: result.getValue('custrecord_form_id'),
            accountId: result.getValue('custrecord_account_id')
        };
    }

    return { getConfig };
});

✅ Reusable across any script — pass your script key and get relevant configuration instantly.

🧠 Step 3: Apply Configuration in Your SuiteScript

define(['N/record', 'N/log', './configUtil'], (record, log, configUtil) => {

    const execute = () => {
        const config = configUtil.getConfig('Invoice_Update', 2); // Subsidiary 2
        if (!config) {
            log.error('No Config Found', 'Please check customrecord_script_config');
            return;
        }

        log.audit('Loaded Config', config);

        const searchId = config.searchId;
        const formId = config.formId;
        const accountId = config.accountId;

        // Use values dynamically
        const inv = record.create({ type: 'invoice', isDynamic: true });
        inv.setValue('customform', formId);
        inv.setValue('account', accountId);
        inv.save();
    };

    return { execute };
});

✅ You can now change saved searches, forms, or accounts without touching the script — just edit your config record.

🧩 Step 4: Script Parameters + Custom Config (Hybrid)

For smaller deployments, use Script Parameters directly.

Example:

Define parameters in your script deployment:

• custscript_form_id
• custscript_search_id

Retrieve them in the script:

const formId = runtime.getCurrentScript().getParameter('custscript_form_id');
const searchId = runtime.getCurrentScript().getParameter('custscript_search_id');

✅ Ideal for per-deployment tweaks without new records.

🔁 Step 5: Environment-Aware Configurations

Add a field in your custom record:

Then use this filter in your utility:

['custrecord_env_type', 'is', runtime.envType]

✅ Ensures scripts automatically pick the right settings based on where they run.

⚡ Step 6: Configuration Validation on Deploy

Add a pre-execution validation in your script:

if (!config || !config.searchId) {
   throw Error('Invalid Configuration: Missing Saved Search ID');
}

✅ Helps catch setup issues before processing records.

🧮 Step 7: Central Dashboard for Configuration Management

Create a Saved Search or SuiteAnalytics Workbook:

• Columns: Script Key, Subsidiary, Status, Updated Date
• Filters: Status = Active
• Purpose: Monitor which configurations are in use

Optionally, build a Suitelet-based “Config Management Dashboard” to allow non-technical users to edit configuration via UI.

🧰 Step 8: Real-World Use Cases

🧩 Step 9: Benefits for Developers & Admins

✅ One codebase across environments
✅ No redeployment needed for logic changes
✅ Easy to audit & document
✅ Ideal for integration-heavy systems
✅ Supports both sandbox and production with zero code changes

⚙️ Step 10: Best Practices

📚 Related Tutorials

• 👉 Performance Optimization for Map/Reduce Scripts
• 👉 Integration Logging & Monitoring Dashboard
• 👉 Custom Error Handling & Retry Framework

❓ FAQ

Q1. Can admins update configurations without script access?
Yes — by using custom records and role-based permissions.

Q2. Can configurations differ per subsidiary or customer type?
Yes — just add those fields in your configuration record.

Q3. How does this compare to SuiteScript parameters?
Custom records are more flexible for multi-environment and multi-tenant setups.

Q4. Is caching necessary?
Yes — caching improves performance by avoiding repeated search calls.

🧭 Summary

A Dynamic Configuration Framework transforms your SuiteScript architecture into a scalable, modular, and reusable system.
Instead of rewriting code, you define your logic externally and deploy it instantly — saving time, improving maintainability, and reducing deployment risk.

This approach is a hallmark of enterprise-level NetSuite customization, used by leading solution providers for integrations, automation, and global rollouts.