📚 How to Validate Low-Side Behavior for Conditional Filtering and Routine Iteration

docs/general/how-to-validate-low-side-behavior-for-conditional-filtering-.md

@@ -0,0 +1,121 @@
+# How to Validate Low-Side Behavior for Conditional Filtering and Routine Iteration
+
+## Overview
+
+This guide explains why low-side environments matter for development and testing, and outlines how to validate that conditional logic (for example, for ACR and channel) is correctly applied at lower Levels of Access (LOA) and on the web. It also summarizes current limitations with pointing Distillery to the ASDK high-side environment.
+
+## Prerequisites
+
+- Access to a **low-side environment** (e.g., development or staging) where you can:
+  - Run the application at **LOA1** (Level of Access 1)
+  - Access the **web** interface
+- A working **Distillery** setup (internal tool) configured for low-side
+- Awareness that:
+  - Distillery **cannot currently be pointed to ASDK high-side** with the correct branch/system version
+  - Relevant pull requests (PRs) may still be in review or pending deployment
+
+> Note: Specific URLs, commands, and configuration files for Distillery and ASDK are not provided in the original discussion and will need to be obtained from your team’s internal documentation or configuration repositories.
+
+## Why Low-Side Validation Matters
+
+1. **Routine Iteration and Development Velocity**  
+   - Low-side environments allow developers to iterate quickly without depending on high-side access or configuration.
+   - Because Distillery cannot yet target ASDK high-side with the correct branch/system version, low-side is currently the primary environment for:
+     - Implementing changes
+     - Running routine tests
+     - Validating conditional logic
+
+2. **Verification of Conditional Logic at Lower LOA**  
+   - Low LOA (e.g., LOA1) and web access are used to confirm that:
+     - Conditional rules for **ACR** (e.g., Access Control Rules or Account/Customer Rules, depending on your system) are applied correctly.
+     - Conditional rules for **channel** (e.g., web, app, API) are applied correctly.
+   - A recent confirmation indicates that **low LOA correctly filters out conditionals for both ACR and channel** when:
+     - The user is on **LOA1**, or
+     - The user is accessing via **web**.
+
+## How to Validate Low-Side Conditional Filtering
+
+1. **Set Up and Access the Low-Side Environment**
+   - Ensure you are running against the **low-side** instance of the application.
+   - Confirm that Distillery is configured to point to the **low-side** target (since high-side ASDK is not yet supported for the correct branch/system version).
+
+2. **Test at LOA1**
+   - Log in or configure your session to operate at **LOA1**.
+   - Navigate to the relevant feature or page where ACR and channel-based conditionals are expected.
+   - Verify that:
+     - Conditionals that should be hidden or filtered at LOA1 are not visible.
+     - Any ACR- or channel-specific content behaves as expected for LOA1.
+
+3. **Test via Web Access**
+   - Access the application via the **web interface**.
+   - Repeat the same checks:
+     - Confirm that ACR and channel conditionals are filtered correctly for web users.
+   - Compare behavior between LOA1 and web to ensure consistency where expected.
+
+4. **Coordinate on Implementation Timing**
+   - If you need a change to be deployed:
+     - Confirm whether the change is expected **today** or at a later time.
+     - Check the status of related **pull requests (PRs)**.
+   - If primary owners (e.g., Joey or others) are busy:
+     - Offer or request a **quick context transfer** so another engineer can complete the work.
+
+5. **Confirm Completion of Related Changes**
+   - Verify whether the main implementation work is already done (e.g., “Joey has mostly finished his change”).
+   - Once merged and deployed, re-run the LOA1 and web tests to confirm the behavior.
+
+## Important Notes and Caveats
+
+- **High-Side Limitation**:  
+  Distillery **cannot currently be pointed to ASDK high-side** with the correct branch/system version. This is why low-side validation is critical for:
+  - Early detection of issues
+  - Routine iteration and testing
+
+- **Incomplete Operational Details**:  
+  The original discussion does not include:
+  - Exact Distillery configuration steps
+  - Specific ASDK environment URLs
+  - Concrete commands or scripts for switching LOA or channels  
+  These details must be obtained from your team’s internal runbooks or environment configuration documentation.
+
+- **Ownership and Handoffs**:  
+  - Changes may be primarily owned by specific engineers (e.g., Joey).
+  - If they are unavailable, a **context transfer** is recommended so others can complete or validate the work.
+
+## Troubleshooting
+
+If conditional filtering does not behave as expected on low-side:
+
+1. **Check Environment Target**
+   - Confirm Distillery is pointing to the **correct low-side environment**.
+   - Ensure you are not accidentally testing against an outdated or misconfigured instance.
+
+2. **Verify LOA and Channel Settings**
+   - Confirm that:
+     - Your session is truly at **LOA1** (or the intended LOA).
+     - You are testing via the intended **channel** (web vs. other channels).
+   - Misconfigured LOA or channel can cause conditionals to appear or disappear unexpectedly.
+
+3. **Confirm Deployment Status**
+   - Ensure the relevant **PRs have been merged and deployed** to the low-side environment.
+   - If a change is “mostly finished,” verify whether it is actually live before testing.
+
+4. **Request or Provide Context Transfer**
+   - If the primary owner is unavailable and you are blocked:
+     - Request a **brief handoff** (context transfer) so you or another engineer can:
+       - Complete the implementation
+       - Adjust configuration
+       - Validate behavior
+
+5. **Information You May Need to Request**
+   - Exact Distillery configuration for:
+     - Low-side target
+     - Intended branch/system version
+   - Documentation on:
+     - How LOA is determined and set in your system
+     - How channel is defined and detected (web vs. other)
+   - Any feature flags or toggles that control ACR/channel conditionals
+
+By ensuring low-side environments are correctly configured and validated, you can reliably test conditional logic and maintain development velocity even while high-side integration remains constrained.
+
+---
+*Source: [Original Slack thread](https://distylai.slack.com/archives/impl-tower-chat-optim/p1761669424640689)*