CSA-C01 cheat sheet

The platform is organized into applications, each containing modules; modules open records, lists, or dashboards in the main content frame.

The Application Navigator (left pane) filters modules by application scope; the filter field matches module and application names as you type.

The banner frame holds global controls: global search, the user menu, the application picker, and the Create New (plus) button.

Global text search queries indexed tables; users can scope searches to specific tables from the search results page.

Impersonation lets an admin view the platform as another user; the session records the impersonator and the impersonated user.

The system dictionary backs all tables and fields; a field's dictionary entry defines its type, length, default, and reference target.

Domain separation partitions data by domain; records are visible only within the user's domain hierarchy unless explicitly shared.

Update sets capture configuration changes for migration between instances; application-scoped changes are captured only when the update set's application matches.

A property is a name/value pair read at runtime via gs.getProperty(); system properties are stored in the sys_properties table.

Property types include string, integer, boolean, choice, password2 (encrypted), and color; type controls the input widget on the form.

sys_scope identifies an application; global scope is 'global', and scoped apps use a unique scope prefix on all artifacts.

Plugins are activated from the plugin list; activation can insert demo data, tables, and properties, and may be irreversible.

Update set batching groups multiple update sets for a single migration; the order of sets within a batch is preserved.

A system clone copies production data to a non-production instance; clone exclusions remove tables and preserve target-only records.

Scheduled jobs, email accounts, and MID Server records are instance-level configuration and are not captured in update sets.

Instance health is checked via system diagnostics, transaction logs, and the slow-query (SQL) logs.

A user record (sys_user) has a user_name that must be unique; email is the typical notification address and need not be unique.

Groups (sys_user_group) collect users; group membership is stored in sys_user_grmember with a user and group reference.

Roles (sys_user_role) grant permissions; roles are assigned to users directly (sys_user_has_role) or inherited through group membership.

Roles can contain other roles (contained roles); a user receives all contained roles transitively.

ACLs evaluate in order of specificity; a table ACL applies to all fields unless a field-level ACL exists.

An ACL requires a security attribute (role, condition, or script); the most specific matching ACL determines access.

The 'admin' role overrides ACL checks; it should be limited to a small set of accounts.

Delegates let a user grant another user their approvals and tasks for a defined date range without sharing credentials.

Tables extend other tables; a child table inherits the parent's fields and adds its own (table-per-hierarchy inheritance).

sys_id is a 32-character unique identifier generated for every record; it is the primary key.

Field types include string, integer, decimal, reference, choice, glide_date, glide_date_time, and journal (additional comments/work notes).

A reference field stores a sys_id pointing to a target table; the reference qualifier limits selectable records.

Choice fields draw options from the sys_choice table; the value stored is the choice value, not the label.

A mandatory field is enforced by the dictionary; a read-only field is enforced by dictionary or UI policy.

Calculated fields and formula-type fields compute values at read time rather than storing them.

Table extension is set at creation and cannot be changed after records exist; plan the hierarchy before loading data.

A filter condition is built from field, operator, and value; conditions combine with AND/OR and can be grouped.

The 'javascript:' prefix in a filter value runs a server-side script to supply dynamic values.

List personalization stores per-user column choices; list configuration stores the default columns for all users.

A related list shows child records linked by a reference field; it is configured on the parent form.

Reports read from a report source (table, report view, or data source); the report view can join tables via related fields.

Report types include list, bar, pie, line, pivot, and trend; trend reports require a date field for the time axis.

Scheduled reports email results on a recurrence; the report must be shared with the recipient or sent by a user with access.

A gauge or scorecard report compares a single aggregate value against a threshold target.

Form layout is controlled by form sections and the form designer; fields can be split across one or two columns per section.

A UI policy sets fields mandatory, read-only, or visible based on conditions evaluated on the client, with an optional server-side script.

UI policy order matters: when multiple policies apply, the last-applied action wins for a given field and attribute.

A data policy enforces mandatory and read-only rules on the server for all data entry paths, including imports and web services.

A client script (onLoad, onChange, onSubmit) runs in the browser; it cannot query the database without GlideAjax.

A UI action adds a button, link, or context-menu item; its condition controls visibility and its script runs client or server side.

Client-side UI actions use the client script API (g_form); server-side actions use current and GlideRecord.

An onCellEdit client script fires when a value changes inline in a list, not on a form.

Business rules run on the server at defined timing: before (query, insert, update, delete), after, async, and display.

A before business rule can modify current before the record is written; an after rule runs post-write and cannot alter the saved values.

Business rule order sets execution sequence among rules on the same table and timing; lower numbers run first.

A script include is a reusable server-side class; it is invoked via new ClassName() or as a static method.

Client-callable script includes must extend AbstractAjaxProcessor and set the client_callable flag, invoked via GlideAjax.

GlideRecord queries use addQuery, addEncodedQuery, query, next, and get; get(sys_id) returns a single record.

setValue on a GlideRecord marks fields dirty; update() writes only changed fields, while setWorkflow(false) skips business rules and workflows.

gs.addInfoMessage, addErrorMessage, and addMessage display session messages to the user after the transaction.

A workflow is a sequence of activities (tasks, approvals, notifications, scripts) triggered by a condition on a table.

Workflow activities include Approval, Task, Notification, Timer, If, and Run Script; transitions define the path.

Flow Designer builds flows from triggers (record created/updated, schedule, form submission) and actions; subflows are reusable flows.

Flow actions wrap script or integration steps; action inputs and outputs define the data contract.

Flow approval actions create approval records and pause the flow until a decision; rejection can branch to a different path.

The approval engine (sysapproval_approver) supports 'any' (first to approve wins) and 'all' (every approver must approve) rules.

Approvals can be generated by workflows, flows, or the Approval Engine via script; state values include requested, approved, rejected.

A workflow context (wf_context) tracks a running workflow's state; workflow versions must be published to take effect.

A catalog item belongs to a category; it defines variables, pricing, fulfillment flow, and availability.

Variable types include single-line text, select box, reference, checkbox, and multi-line text; variable sets group reusable variables.

A record producer creates a record on a target table from a catalog item submission.

Catalog UI policies and client scripts control variable behavior on the catalog form; they reference variable names, not labels.

A knowledge base groups articles; articles have a workflow state (draft, review, published, retired) and a validity period.

Knowledge article versioning keeps prior versions; only the published version is visible to end users.

Knowledge blocks embed reusable content in articles; they update wherever referenced when edited.

Catalog tasks (sc_task) and requested items (sc_req_item) are created during fulfillment; the request (sc_request) groups items.

A notification triggers on a record event (insert, update) or a scheduled condition; it sends email, SMS, or both.

Notification recipients are set by users/groups fields, event parm, or script; who-receives options include record fields and groups.

An email template contains subject and body with ${field} substitution; templates are referenced by notifications and mail scripts.

Events (sysevent) decouple senders from receivers; gs.eventQueue queues an event and registered scripts process it.

A scheduled job runs a script or a report on a recurrence defined by a run time and interval; it runs as the job's run-as user.

Scheduled flows run on a schedule trigger and are managed in Flow Designer rather than the scheduled job table.

Inbound email actions parse incoming messages and can create or update records based on matching conditions.

Notification 'weight' and conditions determine whether a notification fires; the send-ignoring flag in scripts suppresses notifications.

An import set (sys_import_set) holds staged rows from a data source before transformation into target tables.

Data sources include file (CSV, Excel, XML), LDAP, JDBC, and web service; each is loaded into an import set table.

A transform map maps source columns to target fields and defines coalesce keys that match existing records for update.

Coalesce determines insert vs update: if a matching record exists on the coalesce field, it updates; otherwise it inserts.

Transform scripts (onStart, onBefore, onAfter, onComplete) run at defined points to modify or validate mapped data.

Field maps support source scripts and choice mapping to translate source values into target choice values.

A transform map can set a 'run business rules' flag; disabling it skips business rules and workflows during transform.

Import set cleanup removes staged rows after transform; scheduled imports can run a data source load and transform automatically.