Application Properties Configuration

Application Properties Configuration in ServiceNow – Complete Guide for CAD Exam

Introduction

Application Properties Configuration is a fundamental concept in ServiceNow application development. When designing and creating applications on the ServiceNow platform, understanding how to configure application properties ensures that your applications are flexible, maintainable, and adaptable to different environments and customer requirements. This topic is tested on the ServiceNow Certified Application Developer (CAD) exam, and a thorough understanding is essential for success.

Why Application Properties Configuration Is Important

Application properties allow developers to externalize configuration values from hard-coded logic. This is critically important for several reasons:

1. Environment Flexibility: Properties allow applications to behave differently across development, test, and production environments without changing the underlying code.

2. Maintainability: When business rules, scripts, or workflows reference properties instead of hard-coded values, administrators can update behavior without modifying code. This reduces the risk of introducing bugs during changes.

3. Reusability: Applications that use properties are more portable and can be distributed to different ServiceNow instances where each instance may require different configuration values.

4. Security: Sensitive values (such as API keys or integration endpoints) can be stored as system properties with restricted access, rather than being embedded in scripts where they may be visible to a broader audience.

5. Governance and Best Practice: ServiceNow best practices strongly encourage the use of application properties for configurable values, and the CAD exam tests your knowledge of this principle.

What Are Application Properties?

Application properties in ServiceNow are name-value pairs stored in the sys_properties table. They serve as configurable settings that scripts, business rules, UI policies, and other application components can reference at runtime. When you create a scoped application, you can define properties that are specific to your application's scope.

Key characteristics of application properties include:

- Name: A unique identifier for the property, typically following a naming convention like your_app_scope.property_name.
- Value: The configurable data stored in the property (string, boolean, integer, etc.).
- Type: The data type of the property value (e.g., string, integer, boolean, choicelist).
- Description: A human-readable explanation of what the property does.
- Scope: Properties belong to a specific application scope. Scoped properties are accessible only within their scope unless explicitly shared.
- Suffix: The suffix of the property name after the application scope prefix.

How Application Properties Work

1. Creating Application Properties:
To create an application property, navigate to System Properties > My Company's Properties or define them directly within your scoped application via Application Properties module. In a scoped application, you can also create properties through the Studio by navigating to the application and adding a new System Property record.

2. Accessing Properties in Scripts:
In scoped applications, you use the gs.getProperty('property_name') method to retrieve the value of a property. For example:

var myValue = gs.getProperty('x_myapp.my_setting');

This retrieves the current value of the property named x_myapp.my_setting.

To set a property value programmatically, you can use:

gs.setProperty('x_myapp.my_setting', 'new_value');

3. Application Property Categories:
ServiceNow allows you to group related properties into categories using System Property Categories (stored in sys_properties_category). This makes it easier for administrators to find and manage properties through a user-friendly interface. When you create a category, you can assign properties to it, and they will appear together on a configuration page.

4. Property Pages:
You can create custom property pages by defining a System Property Category and associating properties to it. Administrators can then access these grouped properties via a dedicated module, providing a clean UI for configuration without requiring direct table access.

5. Scoped Property Access:
In scoped applications, properties are protected by the application scope. A scoped application can only access its own properties by default. To access properties from another scope, cross-scope access must be explicitly granted through the application's cross-scope privilege settings. This is an important security and governance feature.

6. Default Values:
When creating a property, you can set a default value. If the property is not explicitly configured, the default value is returned when the property is accessed via gs.getProperty(). You can also provide a fallback default directly in the method call:

var myValue = gs.getProperty('x_myapp.my_setting', 'default_fallback');

7. Property Types and the sys_properties Table:
The sys_properties table contains the following key fields: Name, Description, Type (string, integer, boolean, color, etc.), Value, Application (scope), Suffix, and Read/Write Roles. Understanding these fields helps you properly configure properties.

Best Practices for Application Properties Configuration

- Never hard-code values that may change between environments or over time. Always use properties instead.
- Use meaningful naming conventions that include the application scope prefix to avoid naming collisions.
- Document every property with a clear description so administrators understand its purpose.
- Group related properties into categories for easier administration.
- Protect sensitive properties by setting appropriate read and write roles.
- Use the second parameter in gs.getProperty() to provide default values and prevent null reference errors.
- Avoid creating excessive properties – only externalize values that genuinely need to be configurable.

Common Use Cases

- Storing integration endpoint URLs that differ between environments
- Configuring toggle switches (boolean properties) to enable or disable features
- Setting thresholds, limits, or timeout values
- Defining email notification recipients or templates
- Storing API keys or credentials (with proper role-based access control)

Exam Tips: Answering Questions on Application Properties Configuration

The CAD exam may test your understanding of application properties in several ways. Here are essential tips to help you answer these questions correctly:

1. Know the API methods: Remember that gs.getProperty() is used to retrieve a property value and gs.setProperty() is used to set one. These are the primary methods tested. Be aware that in scoped applications, these methods work within the application's scope.

2. Understand scope restrictions: A scoped application can only access its own properties by default. If a question asks about accessing another application's properties, remember that cross-scope access must be explicitly configured. This is a frequently tested concept.

3. Distinguish between system properties and application properties: System properties (global scope) are different from scoped application properties. Know that scoped apps should define their own properties within their scope.

4. Remember the sys_properties table: Questions may reference where properties are stored. The answer is the sys_properties table.

5. Property categories and pages: Understand that sys_properties_category is used to create groupings of properties and that these can be exposed through custom modules for administrator configuration.

6. Default values matter: If a question involves what happens when a property doesn't exist, remember that gs.getProperty() returns null unless a default value is provided as the second argument.

7. Read the question carefully for scope context: Many questions will specify whether you are working in a global or scoped context. Your answer about property access methods and restrictions depends heavily on this detail.

8. Elimination strategy: If you encounter a question about best practices for configurable values, eliminate any answer that suggests hard-coding values in scripts. The correct answer will almost always involve using system properties.

9. Role-based access: Properties can have read and write roles assigned. If a question asks about securing property values, look for answers involving role restrictions on the property record.

10. Practical scenarios: The exam often presents scenario-based questions. For example: A developer needs to allow an administrator to change an integration URL without modifying code. What should the developer do? The answer involves creating a system property and referencing it in the script using gs.getProperty().

11. Property creation in Studio: Know that when working within ServiceNow Studio, you can create application properties directly as part of your scoped application's artifacts.

12. Watch for trick answers: Some options may suggest using system properties modules that are only available in the global scope. In scoped applications, you must use the scoped application's own property mechanisms.

Summary

Application Properties Configuration is a core concept in ServiceNow application development. It enables flexible, maintainable, and secure applications by externalizing configurable values from code. For the CAD exam, focus on understanding how to create, access, and manage properties within scoped applications, the relevant API methods (gs.getProperty() and gs.setProperty()), scope restrictions, the sys_properties table, property categories, and best practices for using properties instead of hard-coded values. Mastering this topic will not only help you on the exam but also make you a more effective ServiceNow developer in real-world projects.