Study guide
10.1 Expression Sets — Calculation Steps, Formulas & Versioning
Salesforce Accredited Agentforce 360 for Public Sector Professional Exam
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Overview, Architecture & Constituent Data Modeling
1.1 AP-222 Exam Blueprint, Passing Standards & Credential Overview 1.2 Public Sector Solutions Layered Architecture & Industry Common Layer 1.3 Person Accounts & Constituent Data Modeling
2 Chapter 2: Licenses, Permits, and Inspections (LPI) — Intake & Issuance
2.1 Regulatory Authorization Types & Application Intake 2.2 Business License & Permit Issuance, Conditions & Status Tracking 2.3 Application Reviews, Multi-Department Approvals & Renewals
3 Chapter 3: Inspections, Code Enforcement, and Compliance
3.1 Inspection Types, Action Plan Templates & Onsite Visit Execution 3.2 Regulatory Codes, Assessment Indicators & In-Field Checklists 3.3 Regulatory Code Violations, Enforcement Actions & Remediation Workflows
4 Chapter 4: Grants Management & Grantmaking Lifecycle
4.1 Funding Programs, Funding Opportunities (NOFOs) & Public Discovery 4.2 Grant Application Intake, Review Workspaces & Multi-Stage Scoring 4.3 Funding Awards, Disbursement Schedules & Post-Award Reporting
5 Chapter 5: Benefits Management & Assistance Programs
5.1 Benefit Programs, Benefit Schedules & Beneficiary Data Architecture 5.2 Discovery Framework Assessments & Question Versioning 5.3 Rules-Based Eligibility Determination & Recertification Lifecycle
6 Chapter 6: Employee Experience & Emergency Response Management
6.1 Public Sector Employee Experience & Workforce Operations 6.2 Emergency Response Management (ERM) Intake, Triage & Incident Dispatch 6.3 Rapid Resource Allocation, Volunteer Coordination & Contact Tracing
7 Chapter 7: Document Processing, Intelligent Automation & Reporting
7.1 Document Checklist Items, Content Management & Upload Portals 7.2 Intelligent Document Automation (IDA), the Document Workspace & the IDA vs. IDA/IFR Decision 7.3 Intelligent Document Reader (OCR with Amazon Textract) & eSignature Integration 7.4 OmniStudio Document Generation & Dynamic PDF Production 7.5 Public Sector Operational Reporting, Compliance Dashboards & CRM Analytics
8 Chapter 8: OmniStudio for Public Sector — Guided Intake & 360 Views
8.1 OmniScript Architecture, Step Design & Conditional Branching 8.2 Data Prefill Patterns, Context Passing & Save-for-Later 8.3 FlexCard Architecture, Constituent 360 Layouts & Action Frameworks
9 Chapter 9: OmniStudio Integration & Server-Side Processing
9.1 Data Mappers (DataRaptors) — Turbo Extract, Extract, Transform & Load 9.2 Integration Procedures — Action Chaining, Batching & Error Handling 9.3 External API Integrations, HTTP Actions & Named Credentials
10 Chapter 10: Business Rules Engine (BRE) & Dynamic Fee Calculation
10.1 Expression Sets — Calculation Steps, Formulas & Versioning 10.2 Decision Tables & Decision Matrices for Policy Decisioning 10.3 Dynamic Fee Schedules, Calculation Procedures & Regulatory Pricing
11 Chapter 11: Experience Cloud Citizen Portals & Service Console
11.1 Public Sector Experience Cloud Site Templates & Citizen Self-Service 11.2 Guest vs. Authenticated User Journeys & Identity Verification 11.3 Multilingual Localization, Custom Labels & Translation Workbench 11.4 Public Sector Service Console, Workspace Tabs & Omni-Channel Routing
12 Chapter 12: Security, Compliance, Government Cloud & Best Practices
12.1 Data Security, Org-Wide Defaults (OWD) & Sharing Architecture 12.2 Government Cloud Tiers, FedRAMP & DoD Compliance 12.3 Salesforce Shield, Field Audit Trail & Platform Encryption 12.4 Declarative-First Strategy, Process Library & Deployment with IDX Workbench
13 Chapter 13: Agentforce & AI Innovation for Public Sector
13.1 Agentforce Architecture, Agent Builder & Public Sector Agents 13.2 Topic Definitions, Instructions, Actions & CRM/Data Cloud Grounding 13.3 Einstein Trust Layer, Guardrails & Responsible AI Governance
14 Chapter 14: Discovery, Requirements & Solution Design
14.1 Documenting Business Needs, Agency Value & Vision for Desired Outcomes 14.2 Discovery & Design Approaches and Solution Documentation 14.3 Mapping Business Processes, Personas & Requirements
15 Chapter 15: Org Setup, Data Management & Integration Governance
15.1 Setting Up an Org for Agentforce Public Sector 15.2 Data Management Strategy, Data Quality & Integration Governance
10.1 Expression Sets — Calculation Steps, Formulas & Versioning
Key Takeaways Explain This Topic AI
Business Rules Engine (BRE) Expression Sets provide a declarative, procedural calculation pipeline in Public Sector Solutions, decoupling complex statutory logic from custom Apex controllers and Flow formulas.
Expression Sets execute steps sequentially from top to bottom, supporting Calculation steps, Lookup Table steps (Decision Matrix/Table), Branching Conditions, Sub-expression sets, and Decision Explanations.
The variable architecture enforces strict data typing across Input, Output, and Intermediate variables, ensuring internal calculation scratchpads are never leaked into external JSON payloads.
Expression Set versioning supports Draft, Active, and Obsolete states with date-effective timestamps (Start/End DateTime) that enable zero-downtime statutory updates and instantaneous emergency rollbacks.
Expression Sets integrate natively with Salesforce Flow via the 'Execute Expression Set' action and OmniStudio Integration Procedures via the 'Business Rules Engine Action', validated pre-deployment using the visual Simulator.
Last updated: September 2026
10.1 Expression Sets — Calculation Steps, Formulas & Versioning
Exam Focus: Public sector regulatory administration relies heavily on statutory fee structures, income-tiered benefit thresholds, and complex policy decisioning that change frequently across legislative cycles. On the AP-222 examination, candidates must master the Business Rules Engine (BRE) and specifically Expression Sets . You must understand how Expression Sets act as procedural calculation pipelines, configure and sequence calculation steps, lookup tables, and branching conditions, leverage sub-expression sets for modularity, manage variable typing and scoping (Input, Output, Intermediate), enforce versioning and date-effective governance without system downtime, and integrate Expression Sets seamlessly with Salesforce Flow and OmniStudio Integration Procedures.
The Architectural Role of Business Rules Engine in Public Sector Solutions
In public sector organizations—such as municipal building departments, state environmental protection agencies, and health and human services bureaus—statutory rules govern every operational decision. Government fee schedules and benefit eligibility formulas are not static business preferences; they are legally enacted by city councils, county boards of supervisors, and state legislatures.
Traditionally, organizations attempted to implement these rules using one of two patterns:
Programmatic Apex Code: Writing custom Apex classes, triggers, and utility services to calculate fees or verify eligibility. While performant, this approach tightly couples legislative policy to software code. Every time a city council passes an ordinance adjusting permit multipliers or poverty guidelines, developers must modify Apex code, update test classes, achieve code coverage thresholds, and execute production deployments. This introduces administrative latency, high operational costs, and regression risks.
Declarative Flow Formulas: Constructing nested formulas inside standard Salesforce Flows. While declarative, complex government calculations involving tiered brackets, square-footage thresholds, and compounding hazard surcharges quickly overwhelm standard Flow formulas, producing unwieldy, unmaintainable logic trees that lack transparent audit trails.
The Business Rules Engine (BRE) , built natively into the Salesforce Industries Common Layer and Public Sector Solutions, solves this architectural dilemma. BRE provides a declarative, high-performance rules and calculation engine that decouples policy logic from application workflows. Non-developer policy analysts and administrators can design, simulate, update, and audit complex calculation rules without touching code. +-----------------------------------------------------------------------------------+
- | Decoupled Architecture of Business Rules Engine (BRE) |
- +-----------------------------------------------------------------------------------+
- | [Presentation Layer] |
- | • Citizen Self-Service Portal (OmniScript) |
- | • Caseworker Adjudication Console (FlexCard / Flow) |
- | • Autonomous Public Sector Agent (Agentforce Action) |
- | │ |
- | ▼ |
- | [Orchestration Layer] |
- | • OmniStudio Integration Procedure (IP) / Salesforce Screen/Autolaunched Flow |
- | │ |
- | ▼ |
- | [Business Rules Engine (BRE)] |
- | • Expression Sets (Procedural Calculations & Decision Pipelines) |
- | • Decision Matrices (In-Memory Tabular Multi-Factor Lookups) |
- | • Decision Tables (Object-Backed Record Matchers) |
- | • Decision Explanations (Statutory Transparency & Audit Tokens) |
- | │ |
- | ▼ |
- | [Persistence & Ledger Layer] |
- | • RegulatoryTrxnFee & RegulatoryTrxnFeeItem Records |
- | • IndividualApplication / BusinessLicenseApplication Audit Logs |
- +-----------------------------------------------------------------------------------+
- Transition from Legacy Vlocity Calculation Procedures
Historically, Salesforce Industries (formerly Vlocity) utilized Calculation Procedures and Calculation Matrices within the OmniStudio package. While functionally powerful, they were configured via proprietary JSON structures and lacked native core Salesforce platform capabilities.
In modern Public Sector Solutions, Expression Sets replace legacy Calculation Procedures. Expression Sets are first-class Salesforce metadata objects built directly on the core Lightning platform. They provide a drag-and-drop visual builder, native integration with Salesforce Flow, sub-expression modularity, and built-in explainability tokens. For the AP-222 exam, candidates must treat Expression Sets as the premier standard for public sector calculations.
Expression Set Architecture & Core Pipeline Elements
An Expression Set is an ordered procedural execution pipeline. It takes a structured input payload, evaluates a sequence of configured steps from top to bottom, performs mathematical calculations and conditional branching, looks up values from reference tables, and returns a structured output payload. +-----------------------------------------------------------------------------------+
- | Core Expression Set Pipeline Execution Steps |
- +-----------------------------------------------------------------------------------+
- | [1. Input Ingestion] ──> Ingests typed variables (Numbers, Text, Booleans) |
- | [2. Lookup Step] ──> Calls Decision Matrix (e.g., Base Permit Fee Lookup) |
- | [3. Calculation Step] ──> Computes Formulas (e.g., Base Fee + (SqFt * Rate)) |
- | [4. Branching Step] ──> Condition: IsAffordableHousing == TRUE? |
- | ├── True: Apply 50% Statutory Fee Waiver |
- | └── False: Apply Standard Commercial Regulatory Rate |
- | [5. Sub-Expression Set] ──> Invokes Reusable State Environmental Fee Pipeline |
- | [6. Explanation Step] ──> Attaches Legal Citation & Justification Tokens |
- | [7. Output Generation] ──> Emits Final Itemized Fees & Total Payable Amount |
- +-----------------------------------------------------------------------------------+
The Five Foundational Pipeline Elements:
Element Type Primary Function Input Dependencies Output Produced Key Public Sector Use Case
Calculation Step Evaluates mathematical equations, arithmetic operations, and string/date formulas Input, Intermediate, or Step variables Updated variable or newly calculated value Calculating incremental square footage fees or late filing penalties
Lookup Table Step Queries a Decision Matrix or Decision Table using input parameters Contextual input attributes Matched matrix row outputs (e.g., Base Fee, Factor) Looking up base commercial building fees by Zoning District and Occupancy Type
Branching Condition Evaluates Boolean expressions ( IF / ELSE IF / ELSE ) to divert execution Conditional logic on any variable Routes execution to True or False branches Bypassing plan review fees for certified non-profit or disaster-relief rebuilds
Sub-expression Set Calls another active Expression Set as a modular child routine Mapped input variables from parent Returned variables mapped back into parent Reusing a standardized state-wide environmental surcharge pipeline across 30 local permits
Decision Explanation Associates explanatory tokens and statutory citations with calculation outcomes Matrix or calculation context Human-readable explanation strings Generating legally defensible audit trails on constituent fee statements
Deep Dive: Step Sequencing and Branching Logic
Steps within an Expression Set execute strictly in sequential order. However, the Branching Condition introduces conditional execution paths:
Conditional Paths: When configuring a Branching step, the architect specifies one or more logical conditions (e.g., ApplicantCategory == 'Veteran' OR IsDisasterVictim == TRUE ).
Branch Isolation: Steps placed within a branch execute only if the condition evaluates to true. If false, the engine either evaluates the next ELSE IF branch or drops into the default ELSE path.
Variable Scope across Branches: Variables calculated inside a specific branch remain accessible to downstream steps following the branch convergence. However, architects must ensure that variables assigned within a conditional branch have defined default fallback values; otherwise, subsequent steps referencing an unassigned variable may fail or produce null pointer evaluations.
Sub-expression Sets: Enterprise Modularity
In complex governmental jurisdictions, multiple agencies share standardized calculation rules. For instance, a state mandate might impose a 2.5% Clean Water Infrastructure Surcharge and a $45 Digital Records Archive Fee on every commercial building, plumbing, electrical, and environmental health permit issued statewide.
Rather than duplicating this identical formula logic across dozens of separate Expression Sets, architects configure a standalone Sub-expression Set :
Encapsulation: The child Expression Set ( State_Mandated_Surcharges ) is authored, tested, and activated independently.
Invocation: Within the primary municipal permit Expression Set, the architect adds a Sub-expression Set step, selecting State_Mandated_Surcharges .
Interface Mapping: The parent Expression Set maps its internal variables (e.g., RawPermitSubtotal ) to the child's input variables ( BaseAmount ) and receives the calculated surcharges back into parent output variables.
Maintenance Efficiency: When the state legislature updates the Clean Water surcharge from 2.5% to 3.0%, administrators update only the Sub-expression Set. All parent permit calculation pipelines inherit the updated rate instantly without individual modification.
Variables, Data Typing & In-Flight Calculation Logic
Variables represent the data contracts of an Expression Set. They define what information enters the pipeline, what scratchpad memory is utilized during processing, and what data is returned to the caller.
Variable Classifications & Scoping Rules: +-----------------------------------------------------------------------------------+
- | Expression Set Variable Scoping |
- +-----------------------------------------------------------------------------------+
- | [INPUT VARIABLES] [INTERMEDIATE VARIABLES] [OUTPUT VARIABLES] |
- | • Passed by Caller • Internal Scratchpad Only • Returned to Caller |
- | • Read-Only by Default • Read / Write during Pipeline • Read / Write |
- | • Examples: • Examples: • Examples: |
- | - GrossSquareFootage - IncrementalSqFt - BasePermitFee |
- | - ApplicantIncome - SurchargeSubtotal - PlanCheckFee |
- | - HazardClassification - DiscountFactorApplied - TotalPayableFee |
- +-----------------------------------------------------------------------------------+
Input Variables: Attributes supplied by the calling process (such as an OmniScript step, an Integration Procedure, or a Salesforce Flow). Inputs can be configured as mandatory or optional. If marked as a Collection (List) , the Expression Set can process arrays of incoming records.
Output Variables: Explicitly flagged attributes that the Expression Set returns to the calling environment. Only variables explicitly marked as outputs appear in the final response payload.
Intermediate (Internal) Variables: Scratchpad variables used exclusively within the pipeline for temporary calculations (e.g., ExcessSquareFootage = MAX(0, TotalSquareFootage - 2000) ). Intermediate variables are never exposed in the return payload, keeping JSON payloads lean and preventing internal algorithmic mechanics from cluttering external interfaces.
Supported Data Types & Decimal Precision:
Text: String values used for categorizations, zoning codes, and picklist matching (e.g., ZoningDistrict = 'C-3' ).
Number: Numeric quantities. Architects can configure explicit decimal precision (from 0 to 18 decimal places), vital for scientific formulas or fractional square-footage calculations.
Currency: Monopolizes financial amounts, automatically observing org-level multi-currency formatting and precision.
Percent: Fractional ratios evaluated as percentages (e.g., entering 15 represents 15% or 0.15 in calculation steps depending on configuration).
Boolean: Logical TRUE or FALSE flags for conditional branching.
Date & DateTime: Temporal values used for calculating age, elapsed days, filing deadlines, and penalty accrual windows.
In-Flight Formula Syntax & Mathematical Functions
Calculation steps support a rich library of mathematical, logical, and temporal functions:
Function Category Functions Available Operational Example Public Sector Context
Arithmetic & Math + , - , * , / , ROUND , CEIL , FLOOR , ABS , POWER ROUND(BaseFee * 1.0825, 2) Computing state sales/use tax rounded to nearest cent
Statistical & Bounds MAX , MIN , AVG , SUM MAX(500, SqFt * 1.25) Enforcing a statutory minimum permit fee floor of $500
Logical Evaluation IF , AND , OR , NOT IF(IsHistoric == TRUE, Fee * 1.20, Fee) Assessing 20% historic district architectural review surcharge
Date Manipulation DATEVALUE , AGE , DAYS_BETWEEN DAYS_BETWEEN(DueDate, FilingDate) Calculating elapsed days past statutory deadline for late penalties
Collection Functions COUNT , SUM_OF , FILTER SUM_OF(ItemizedEquipmentFees) Summing fees across multiple commercial boilers or elevators
Important
Division by Zero Defense: In production public sector Expression Sets, formulas must defensively guard against division by zero. If a formula divides by a variable representing unit count or square footage (e.g., CostPerOccupant = TotalFee / OccupantCount ), the architect must implement a preceding Branching Condition verifying OccupantCount > 0 , or utilize an inline logical formula IF(OccupantCount > 0, TotalFee / OccupantCount, 0) to prevent fatal runtime calculation exceptions.
Versioning Lifecycle, Effective Dating & Zero-Downtime Governance
Public sector legislation moves on strict statutory schedules. Municipal fee schedules frequently take effect at 12:01 AM on the first day of a new fiscal year (e.g., July 1 or October 1). Simultaneously, legal challenges or administrative appeals may require an immediate rollback of an enacted fee formula. Expression Sets provide a robust versioning framework designed specifically for zero-downtime governance. +-----------------------------------------------------------------------------------+
- | Expression Set Versioning Lifecycle |
- +-----------------------------------------------------------------------------------+
- | [Version 1: Active] |
- | • Start DateTime: 2025-07-01 00:00:00 UTC |
- | • End DateTime: 2026-06-30 23:59:59 UTC |
- | • Status: Active (Immutable, Executing Production Transactions) |
- | |
- | [Version 2: Draft ──> Scheduled Active] |
- | • Created: 2026-05-15 (Under Active Configuration & Simulator Testing) |
- | • Start DateTime: 2026-07-01 00:00:00 UTC |
- | • End DateTime: Null (Open-ended) |
- | • Activation: Admin activates in advance; engine auto-switches on July 1 |
- | |
- | [Version 1: Automatically Becomes Obsolete on July 1] |
- | • Status: Obsolete (Archived, Retained for Audit & Instant Emergency Rollback) |
- +-----------------------------------------------------------------------------------+
The Three Version States:
Draft: The mutable working copy. Architects add steps, adjust formulas, and run simulation tests in Draft mode. A Draft version cannot be invoked by production runtimes if an active version exists.
Active: The immutable production version. When a version is activated, its steps, formulas, and variable mappings are permanently locked to prevent in-flight schema corruption. Only one version of an Expression Set can be active for any specific execution timestamp.
Obsolete: Deactivated prior versions. When a new version is activated with an overlapping timeframe, or when an active version is manually superseded, the prior version transitions to Obsolete. Obsolete versions are retained indefinitely in metadata, maintaining historical audit integrity and allowing administrators to inspect the exact formula that governed a permit issued five years earlier.
Effective Dating (Start Date & Time / End Date & Time)
Effective dating allows agencies to achieve zero-downtime policy deployments :
Instead of requiring an administrator to log into production at midnight on New Year's Eve to activate a new fee schedule, the administrator creates Version 2 weeks in advance.
The administrator sets Start DateTime to 2027-01-01 00:00:00 UTC and activates Version 2.
Both Version 1 and Version 2 are saved in the system. The BRE runtime engine evaluates the execution timestamp of incoming transactions:
Any transaction executed at 2026-12-31 23:59:59 is evaluated by Version 1.
Any transaction executed at 2027-01-01 00:00:01 is automatically evaluated by Version 2.
No deployment window, scheduled maintenance outage, or manual intervention is required.
Emergency Rollback Strategy
If a state court issues an emergency injunction staying an enacted fee hike, an administrator can execute an immediate rollback:
Open the contested Active Version (Version 2) and deactivate it.
Open the prior Obsolete Version (Version 1) and click Activate .
All OmniScripts, Flows, and Integration Procedures immediately revert to executing Version 1 calculations without requiring code redeployment or cache invalidation.
Integration Patterns: Invoking Expression Sets from Flow & OmniStudio
Expression Sets are designed to be invoked headless across multiple Salesforce declarative and programmatic tools.
1. Integration with Salesforce Flow
In Salesforce Flow (Screen Flows, Autolaunched Flows, or Record-Triggered Flows), Expression Sets are exposed as standard platform actions:
Action Type: Under the Business Rules Engine category, select Execute Expression Set .
Input Mapping: Flow variables (such as $Record.GrossSquareFootage__c and $Record.ZoningType__c ) are mapped directly to the Expression Set's input parameters.
Output Handling: The action exposes all Expression Set output variables as strongly typed Flow variables, ready for direct assignment to sObject records or display on Flow screens. +-----------------------------------------------------------------------------------+
- | Salesforce Flow ──> Expression Set Flow |
- +-----------------------------------------------------------------------------------+
- | [Record-Triggered Flow on BusinessLicenseApplication] |
- | │ |
- | ▼ |
- | [Action: Execute Expression Set] |
- | • Selected Set: Commercial_Permit_Fee_Calculator |
- | • Input: GrossSqFt <── $Record.Building_Square_Footage__c |
- | • Input: Zoning <── $Record.Zoning_Classification__c |
- | │ |
- | ▼ |
- | [Output Mapping] |
- | • $Record.Total_Fee_Amount__c <── Output: TotalPermitFee |
- | • $Record.Plan_Review_Fee__c <── Output: PlanReviewFee |
- | │ |
- | ▼ |
- | [Update Records: BusinessLicenseApplication] |
- +-----------------------------------------------------------------------------------+
- 2. Integration with OmniStudio Integration Procedures (IPs)
In citizen self-service portals built on OmniStudio, calling an Expression Set directly from the browser would violate the single network round-trip principle. Instead, architects route calculation requests through an Integration Procedure (IP) :
IP Element: Insert a Business Rules Engine Action (or Calculation Action) into the IP canvas.
Configuration: Select the Expression Set name. Map incoming JSON nodes from the OmniScript (e.g., %Step_FacilityDetails:SquareFootage% ) into the Expression Set input variables.
Response Aggregation: The IP captures the Expression Set's output JSON and merges it with other server-side operations (such as Data Mapper Loads creating RegulatoryTrxnFee records) before returning a consolidated response to the OmniScript.
3. In-Flight Testing via the Expression Set Simulator
Prior to activating any Expression Set version, administrators must validate calculation accuracy using the built-in Expression Set Simulator located directly within the builder interface:
Mock Data Entry: Enter arbitrary test values for all input variables (e.g., SquareFootage = 7500 , Zoning = 'Commercial' , IsNonProfit = FALSE ).
Step-by-Step Traversal: The simulator executes the pipeline node-by-node, highlighting the exact execution path taken through conditional branches.
Variable State Inspection: At each step, the inspector panel displays the before-and-after values of intermediate and output variables, allowing developers to detect formula rounding errors, unmet branch criteria, or unhandled null values before production release.
- 💡 Real-World AP-222 Exam Scenarios
- Scenario 1: Multi-Tiered Commercial Cannabis Licensing Fee Pipeline
A state bureau of cannabis control establishes a dynamic licensing fee structure based on cultivation canopy square footage and social equity eligibility:
- Tier 1 (Up to 5,000 sq ft): Base fee $1,500;
- Tier 2 (5,001 to 20,000 sq ft): Base fee $1,500 + $0.50 per sq ft over 5,000;
- Tier 3 (Over 20,000 sq ft): Base fee $9,000 + $0.75 per sq ft over 20,000;
- Social Equity Applicants receive a mandatory 60% fee waiver across all components;
All applicants must pay a standard $250 state agricultural pesticide monitoring surcharge.
How should an enterprise architect structure this calculation in Public Sector Solutions?
Architectural Solution:
Create an Expression Set with Inputs: CanopySqFt (Number), IsSocialEquity (Boolean).
Step 1 (Lookup Table): Query a Decision Matrix with canopy ranges to retrieve BaseFee and IncrementalRatePerSqFt .
Step 2 (Calculation Step): Compute RawFee = BaseFee + (MAX(0, CanopySqFt - TierThreshold) * IncrementalRatePerSqFt) .
Step 3 (Branching Condition): If IsSocialEquity == TRUE , execute Calculation Step DiscountedFee = RawFee * 0.40 ; else DiscountedFee = RawFee .
Step 4 (Sub-expression Set): Call child Expression Set State_Pesticide_Surcharge_Pipeline which calculates and returns PesticideSurcharge = 250 .
Step 5 (Calculation Step): Calculate TotalFee = DiscountedFee + PesticideSurcharge .
Step 6 (Decision Explanation): Attach token EQUITY_DISCOUNT_APPLIED if discounted, ensuring compliance transparency.
Scenario 2: Zero-Downtime Fiscal Year Regulatory Rate Transition
A municipal department of building inspections has an active Expression Set (Version 1) calculating residential addition permits. The city council approves a 4.5% rate increase effective precisely at 00:00:00 UTC on October 1st. The department cannot take its citizen portal offline or risk transaction failures during the transition.
What configuration procedure must the technical specialist follow?
Architectural Procedure:
Open the existing Expression Set and click Save as New Version to create Version 2 in Draft status.
Update the calculation steps in Version 2 with the 4.5% rate adjustments.
In the Version 2 Settings, set Start DateTime to October 1, 00:00:00 UTC and leave End DateTime blank.
Use the Expression Set Simulator to thoroughly validate calculations against test boundary conditions.
Click Activate on Version 2.
Result: Version 1 continues processing all transactions up to September 30, 23:59:59 UTC. The instant the clock strikes October 1, 00:00:00 UTC, the BRE runtime automatically switches execution to Version 2 with zero portal downtime and zero manual midnight operations.