diff --git a/lightning_page_components/DetectAndLaunch/ANALYSIS.md b/lightning_page_components/DetectAndLaunch/ANALYSIS.md
new file mode 100644
index 000000000..4a3ea9a1f
--- /dev/null
+++ b/lightning_page_components/DetectAndLaunch/ANALYSIS.md
@@ -0,0 +1,276 @@
+# DetectAndLaunch Component - Technical Analysis
+
+## Overview
+A Lightning Aura component that automatically detects record changes and launches screen flows based on configurable triggers.
+
+## Component Architecture
+
+### Files Structure
+- **detectAndLaunch.cmp** - Main component markup (58 lines)
+- **detectAndLaunchController.js** - Event handlers and initialization (83 lines)
+- **detectAndLaunchHelper.js** - Business logic for flow launching (88 lines)
+- **detectAndLaunchRenderer.js** - Empty renderer (custom rendering not used)
+- **detectAndLaunch.css** - Empty stylesheet (no custom styling)
+- **detectAndLaunch.design** - Lightning App Builder configuration
+- **detectAndLaunch.cmp-meta.xml** - Metadata (API version 48.0)
+
+## Functionality
+
+### Core Features
+1. **Record Change Detection**
+   - Uses `force:recordData` to monitor record changes
+   - Detects: CHANGED, REMOVED, LOADED events
+   - Watches specific fields when configured
+
+2. **Flow Launch Modes**
+   - **Modal**: Opens flow in a modal dialog
+   - **Modeless**: Opens in new tab/window (default)
+   - Console-aware: Uses subtabs in Service Console
+
+3. **Conditional Launching**
+   - Can trigger based on specific field value changes
+   - Supports field comparison logic
+
+### Component Attributes
+
+| Attribute | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `editFlowName` | String | - | Flow to launch on record edit |
+| `deleteFlowName` | String | - | Flow to launch on record delete |
+| `loadFlowName` | String | - | Flow to launch on record load |
+| `fieldChange` | String | - | Field to watch for changes |
+| `fieldValue` | String | - | Value to match for conditional launch |
+| `launchMode` | String | "Modeless" | Modal or Modeless launch |
+| `recordId` | String | - | Inherited from `force:hasRecordId` |
+
+## Code Analysis
+
+### Strengths ✅
+
+1. **Console Navigation Support**
+   - Properly detects console vs standard UI
+   - Uses WorkspaceAPI for subtab management
+   - Falls back to window.open for standard UI
+
+2. **Page Builder Protection**
+   - Checks for `flexipageEditor` in URL
+   - Prevents execution during page configuration
+
+3. **Flexible Configuration**
+   - Multiple trigger types (edit/delete/load)
+   - Conditional field-based triggering
+   - Configurable launch modes
+
+4. **Error Handling**
+   - Checks for null/undefined flow names
+   - Handles console API errors with catch blocks
+   - Passes recordId to flows as input variable
+
+### Issues & Concerns ⚠️
+
+#### 1. **Excessive Console Logging**
+```javascript
+// Lines 3, 7, 9, 13, 16, 19, 22, 29, 30, etc.
+console.log('entering processChangeEvent');
+console.log('currentUrl is: ' + currentUrl);
+// ... many more console.log statements
+```
+**Impact**: Performance overhead, potential security concerns (exposes internal logic)
+**Recommendation**: Remove or wrap in debug mode flag
+
+#### 2. **Inconsistent Null Checking**
+```javascript
+// Line 32-33: Checks for null/undefined
+if (flowApiName == null || flowApiName == undefined) {
+```
+**Issue**: Uses loose equality (`==`) instead of strict (`===`)
+**Recommendation**: Use `===` or leverage JavaScript truthiness
+
+#### 3. **String Concatenation Instead of Template Literals**
+```javascript
+// Line 18, 65, 78
+var targetUrl = '/flow/' + component.get("v.targetFlowName") + '?recordId=' + component.get("v.recordId");
+```
+**Recommendation**: Use template literals for better readability:
+```javascript
+var targetUrl = `/flow/${component.get("v.targetFlowName")}?recordId=${component.get("v.recordId")}`;
+```
+
+#### 4. **Missing Error Handling for Flow Launch**
+```javascript
+// Line 51: No try-catch around flow.startFlow
+flow.startFlow(flowApiName, inputVariable);
+```
+**Issue**: If flow fails to start, error may not be handled gracefully
+**Recommendation**: Add error handling
+
+#### 5. **Hardcoded Input Variable Name**
+```javascript
+// Line 41: Always uses "recordId" as input variable name
+name : "recordId",
+```
+**Issue**: Assumes all flows have a "recordId" input variable
+**Recommendation**: Make this configurable
+
+#### 6. **Modal Implementation Issues**
+- Modal container has hardcoded height (600px) - may not be responsive
+- Commented-out header/footer code suggests incomplete implementation
+- No close button functionality visible in controller
+
+#### 7. **Field Watching Logic Complexity**
+```javascript
+// Lines 39-57: Complex nested conditionals for field value matching
+if(component.get("v.fieldChange") != null && component.get("v.fieldValue") != null ){
+    // ... nested logic
+}
+```
+**Issue**: Difficult to maintain and extend
+**Recommendation**: Extract to separate helper method
+
+#### 8. **No Input Validation**
+- No validation that flow names are valid
+- No check if flows are active
+- No validation of field API names
+
+#### 9. **API Version**
+- Using API version 48.0 (from 2020)
+- Consider updating to latest version for new features
+
+#### 10. **Missing Documentation**
+- No JSDoc comments
+- Limited inline comments
+- No usage examples in code
+
+## Security Considerations
+
+### Current State
+- ✅ Uses `with sharing` context (inherited from platform)
+- ✅ No direct DML operations
+- ✅ Uses platform APIs (force:recordData, lightning:flow)
+
+### Potential Concerns
+1. **Console Logging**: May expose sensitive data in browser console
+2. **URL Construction**: Direct string concatenation could be vulnerable if inputs aren't sanitized (though Salesforce platform handles this)
+3. **No CSRF Protection**: Relies on Salesforce platform security
+
+## Performance Considerations
+
+1. **Record Data Watching**: Only watches specified fields (efficient)
+2. **Console Logging**: Excessive logging may impact performance
+3. **Modal Rendering**: Modal only renders when needed (good use of aura:if)
+4. **Event Handling**: Single event handler for all change types (efficient)
+
+## Recommendations for Improvement
+
+### High Priority
+1. **Remove/Reduce Console Logging**
+   - Add debug mode flag
+   - Use conditional logging
+
+2. **Add Error Handling**
+   - Wrap flow.startFlow in try-catch
+   - Provide user feedback on errors
+
+3. **Improve Null Checking**
+   - Use strict equality (`===`)
+   - Leverage JavaScript truthiness
+
+4. **Make Input Variable Configurable**
+   - Add attribute for input variable name
+   - Support multiple input variables
+
+### Medium Priority
+5. **Refactor Field Watching Logic**
+   - Extract to separate method
+   - Simplify conditional logic
+
+6. **Update Code Style**
+   - Use template literals
+   - Modern JavaScript practices
+
+7. **Add Input Validation**
+   - Validate flow names
+   - Validate field API names
+
+8. **Improve Modal Implementation**
+   - Make height responsive
+   - Add proper close functionality
+   - Complete header/footer if needed
+
+### Low Priority
+9. **Add Documentation**
+   - JSDoc comments
+   - Usage examples
+   - Inline comments for complex logic
+
+10. **Update API Version**
+    - Test with latest API version
+    - Leverage new platform features
+
+11. **Add Unit Tests**
+    - Test change detection logic
+    - Test flow launching scenarios
+    - Test error handling
+
+## Usage Patterns
+
+### Basic Usage
+```xml
+<!-- Launch flow on record edit -->
+<c:detectAndLaunch 
+    editFlowName="MyEditFlow"
+    launchMode="Modal"
+/>
+```
+
+### Conditional Launch
+```xml
+<!-- Launch flow when StageName changes to "Closed Won" -->
+<c:detectAndLaunch 
+    editFlowName="OpportunityClosedFlow"
+    fieldChange="StageName"
+    fieldValue="Closed Won"
+    launchMode="Modeless"
+/>
+```
+
+### Multiple Triggers
+```xml
+<!-- Different flows for different events -->
+<c:detectAndLaunch 
+    editFlowName="EditFlow"
+    deleteFlowName="DeleteFlow"
+    loadFlowName="LoadFlow"
+/>
+```
+
+## Dependencies
+
+- **force:recordData** - Record change detection
+- **lightning:workspaceAPI** - Console navigation
+- **lightning:flow** - Flow execution
+- **flexipage:availableForAllPageTypes** - Page builder support
+- **force:hasRecordId** - Record context
+- **lightning:isUrlAddressable** - URL navigation
+
+## Testing Considerations
+
+### Test Scenarios
+1. Record edit detection
+2. Record delete detection
+3. Record load detection
+4. Field value conditional launch
+5. Modal vs Modeless launch
+6. Console vs Standard UI
+7. Page builder mode (should not execute)
+8. Error scenarios (invalid flow name, etc.)
+
+## Conclusion
+
+The DetectAndLaunch component is a functional solution for automatic flow launching based on record changes. It demonstrates good understanding of Salesforce platform capabilities and console navigation. However, it would benefit from code cleanup, improved error handling, and better maintainability practices.
+
+**Overall Assessment**: ⭐⭐⭐ (3/5)
+- Functional and works as intended
+- Needs code quality improvements
+- Good foundation for enhancement
+
diff --git a/lightning_page_components/DetectAndLaunch/FIX_PLAN.md b/lightning_page_components/DetectAndLaunch/FIX_PLAN.md
new file mode 100644
index 000000000..096f8f67b
--- /dev/null
+++ b/lightning_page_components/DetectAndLaunch/FIX_PLAN.md
@@ -0,0 +1,223 @@
+# DetectAndLaunch Component - Fix Plan
+
+Based on technical analysis and community feedback from [UnofficialSF](https://unofficialsf.com/from-andy-haas-trigger-screen-flows-with-record-changes-using-detect-and-launch/), here's a prioritized plan to fix and enhance the component.
+
+## Priority 1: Critical Fixes (Must Fix)
+
+### 1.1 Remove/Reduce Console Logging
+**Issue**: 20+ console.log statements impact performance and expose internal logic
+**Files**: `detectAndLaunchController.js`, `detectAndLaunchHelper.js`
+**Action**:
+- Remove all console.log statements from production code
+- Add a debug mode attribute (optional)
+- Keep only critical error logging
+
+**Lines to fix**:
+- Controller: 34, 41, 42, 45, 50, 59, 76, 77
+- Helper: 3, 7, 9, 13, 16, 19, 22, 29, 30, 33, 50, 53, 60, 74, 77, 79
+
+### 1.2 Fix Loose Equality Checks
+**Issue**: Using `==` instead of `===` can cause unexpected type coercion
+**Files**: `detectAndLaunchHelper.js`
+**Action**: Replace all `==` and `!=` with `===` and `!==`
+
+**Lines to fix**:
+- Line 32: `if (flowApiName == null || flowApiName == undefined)` → `if (!flowApiName)`
+- Line 35: `if(component.get("v.launchMode") == 'Modal')` → `if(component.get("v.launchMode") === 'Modal')`
+- Line 39: `if(component.get("v.fieldChange") != null && component.get("v.fieldValue") != null)` → Use strict checks
+
+### 1.3 Fix Null Value Error in Field Comparison
+**Status**: ✅ **FIXED**
+**Issue**: Calling `.toString()` on null field values causes runtime error
+**Files**: `detectAndLaunchController.js`
+**Fix Applied**: Added null check before calling toString() on field value
+- Check if `fieldData` exists and `fieldData.value != null` before calling `.toString()`
+- Prevents "Cannot read property 'toString' of null" errors
+
+**Lines fixed**:
+- Lines 49-56: Added proper null checking with `fieldData && fieldData.value != null`
+
+### 1.4 Add Error Handling for Flow Launch
+**Issue**: No try-catch around `flow.startFlow()` - errors not handled gracefully
+**Files**: `detectAndLaunchHelper.js`
+**Action**: Wrap flow.startFlow in try-catch block
+
+**Lines to fix**:
+- Line 51: Add try-catch around `flow.startFlow()`
+
+### 1.5 Fix Modal Close Functionality (Optional Feature)
+**Issue**: Modal header/footer are commented out - no way to close modal
+**Files**: `detectAndLaunch.cmp`, `detectAndLaunchController.js`
+**Action**: 
+- Add new attribute `enableModalClose` (default: false) to avoid breaking changes
+- Uncomment and fix modal header with close button, but only show when enabled
+- Users must explicitly enable this feature if they want modal close functionality
+
+**Breaking Change Consideration**: 
+- This must be **disabled by default** to maintain backward compatibility
+- Existing users who have built flows expecting the current modal behavior won't be affected
+- Users can opt-in by setting `enableModalClose="true"`
+
+**New attribute needed**:
+```xml
+<aura:attribute name="enableModalClose" type="Boolean" default="false" description="Enable close button in modal. Disabled by default to maintain backward compatibility."/>
+```
+
+**Lines to fix**:
+- Lines 35-38: Conditionally show header with close button based on `enableModalClose` attribute
+- Ensure closeModal controller method works properly
+
+## Priority 2: Important Improvements (Should Fix)
+
+### 2.1 Make Input Variable Name Configurable
+**Status**: ❌ **Won't Fix** - Doesn't align with component design
+
+**Issue**: Hardcoded "recordId" input variable name - assumes all flows use this
+**Reason for Not Implementing**: 
+- The component is designed to watch a specific record and launch flows based on record changes
+- The component inherits `force:hasRecordId` and is fundamentally built around the recordId context
+- Making the input variable configurable would conflict with the component's core purpose of detecting and responding to changes on the watched record
+- Users who need different input variables should use the recordId in their flows and map it to their desired variable names
+
+**Decision**: Keep hardcoded "recordId" as it's central to the component's functionality
+
+### 2.2 Improve Code Readability with Template Literals
+**Issue**: String concatenation is harder to read and maintain
+**Files**: `detectAndLaunchHelper.js`
+**Action**: Replace string concatenation with template literals
+
+**Lines to fix**:
+- Line 18: `/flow/${component.get("v.targetFlowName")}?recordId=${component.get("v.recordId")}`
+- Line 65: Same pattern
+- Line 78: Same pattern
+
+### 2.3 Refactor Field Watching Logic
+**Issue**: Complex nested conditionals in recordUpdated method
+**Files**: `detectAndLaunchController.js`
+**Action**: Extract field value matching logic to helper method
+
+**New helper method needed**:
+```javascript
+checkFieldValueMatch: function(component, eventParams) {
+    // Extract the complex field matching logic here
+}
+```
+
+### 2.4 Add Input Validation
+**Issue**: No validation that flow names are valid or flows are active
+**Files**: `detectAndLaunchController.js`, `detectAndLaunchHelper.js`
+**Action**: Add validation before attempting to launch flows
+
+**Validation needed**:
+- Check if flow name is provided
+- Check if flow name is not empty
+- Optionally: Validate field API names
+
+### 2.5 Fix Modal Height Issue
+**Issue**: Hardcoded 600px height - not responsive
+**Files**: `detectAndLaunch.cmp`
+**Action**: Use responsive CSS classes or remove fixed height
+
+**Lines to fix**:
+- Line 31: Remove `style="height: 600px;"` or make it responsive
+
+## Priority 3: Enhancements (Nice to Have)
+
+### 3.1 Support Multiple Field Conditions
+**Issue**: Can only watch one field at a time
+**Files**: All component files
+**Action**: Add support for multiple field/value pairs (requires significant refactoring)
+
+**Note**: This is a major enhancement, consider as separate feature request
+
+### 3.2 Support Conditional Launch on Load/Delete
+**Status**: ❌ **Cannot be Supported**
+
+**Issue**: Conditional field-based launch only works on edit (per blog post limitations)
+**Reason**: 
+- The component architecture is designed to watch record changes and evaluate field conditions during edit events
+- LOADED events don't have "changedFields" data to compare against
+- REMOVED events occur when the record is deleted, so field value comparisons aren't meaningful
+- This limitation is by design and cannot be supported with the current architecture
+
+**Decision**: Keep as documented limitation - conditional field-based launch only works on CHANGED events
+
+### 3.3 Add JSDoc Documentation
+**Issue**: No function documentation
+**Files**: All JS files
+**Action**: Add JSDoc comments to all functions
+
+**Example**:
+```javascript
+/**
+ * Processes record change events and launches appropriate flows
+ * @param {Component} component - The component instance
+ * @param {Object} eventParams - Event parameters from force:recordData
+ */
+processChangeEvent: function(component, eventParams) {
+    // ...
+}
+```
+
+### 3.4 Update API Version
+**Issue**: Using API version 48.0 (from 2020)
+**Files**: `detectAndLaunch.cmp-meta.xml`
+**Action**: Test and update to latest API version (currently 62.0+)
+
+**Note**: Test thoroughly before updating
+
+### 3.5 Add User Feedback for Errors
+**Issue**: Errors are only logged to console
+**Files**: `detectAndLaunchController.js`, `detectAndLaunchHelper.js`
+**Action**: Add toast messages or error display for user-facing errors
+
+## Implementation Order
+
+### Phase 1: Critical Fixes (Week 1)
+1. ✅ Fix null value error in field comparison (COMPLETED)
+2. Remove console logging
+3. Fix equality checks
+4. Add error handling for flow launch
+5. Fix modal close functionality (as optional feature, disabled by default)
+
+### Phase 2: Important Improvements (Week 2)
+1. Use template literals
+2. Refactor field watching logic
+3. Add input validation
+4. Fix modal height
+
+### Phase 3: Enhancements (Week 3+)
+1. Add documentation
+2. Update API version
+3. Add user feedback
+4. Consider major enhancements (multiple fields)
+
+## Testing Checklist
+
+After each fix, test:
+- [ ] Record edit detection
+- [ ] Record delete detection
+- [ ] Record load detection
+- [ ] Field value conditional launch
+- [ ] Modal launch mode
+- [ ] Modeless launch mode
+- [ ] Console navigation
+- [ ] Standard UI navigation
+- [ ] Page builder mode (should not execute)
+- [ ] Error scenarios (invalid flow name, missing flow, etc.)
+- [ ] Multiple component instances on same page
+
+## Known Limitations (From Blog Post)
+
+These are documented limitations, not bugs:
+1. **Cross-field comparisons not supported** - Change Value must be static
+2. **Conditional launch only on edit** - Conditional field-based launch only works on CHANGED events, not LOADED or REMOVED (by design - cannot be supported)
+3. **Modal close function** - Users need to build close function in flow (now optional via `enableModalClose` attribute, disabled by default)
+4. **Input variable name** - Hardcoded to "recordId" (by design - component is built around recordId context)
+
+## References
+
+- [UnofficialSF Blog Post](https://unofficialsf.com/from-andy-haas-trigger-screen-flows-with-record-changes-using-detect-and-launch/)
+- Component Analysis: `ANALYSIS.md`
+- Component Source: `force-app/main/default/aura/detectAndLaunch/`
+
diff --git a/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.cmp b/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.cmp
index ede90de63..701a591dc 100755
--- a/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.cmp
+++ b/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.cmp
@@ -1,5 +1,6 @@
 <aura:component implements="flexipage:availableForAllPageTypes, force:hasRecordId,lightning:isUrlAddressable"> <!--inherit recordId attribute-->
     <lightning:workspaceAPI aura:id="workspace" />
+    <lightning:notificationsLibrary aura:id="notifLib"/>
    
 
     <aura:attribute name="recordError" type="String" description="An error message bound to force:recordData"/>
@@ -10,6 +11,7 @@
     <aura:attribute name="fieldValue" type="String" description="Launch this flow when the record is edited and this field equals this"/>
     <aura:attribute name="targetFlowName" type="String"  />
     <aura:attribute name="launchMode" type="String" default="Modeless" description="Launch this flow when the record changes"/>
+    <aura:attribute name="debugMode" type="Boolean" default="false" description="Enable debug logging to console. Disabled by default for performance."/>
 
     <force:recordData aura:id="recordLoader"
     fields="{!v.fieldNameList}"
@@ -28,9 +30,9 @@
     
     <!-- Here we wrapped our modal code inside aura:if. If it evaluates true, code inside it will be visible -->
     <aura:if isTrue="{!v.openModal}" >
-      <div class="demo-only" style="height: 600px;">
+      <div class="slds-modal-container">
         <section role="dialog" tabindex="-1" aria-labelledby="modal-heading-01" aria-modal="true" aria-describedby="modal-content-id-1" class="slds-modal slds-fade-in-open">
-            <div class="slds-modal__container">
+            <div class="slds-modal__container slds-modal__container--responsive">
               <!-- Header of Modal -->
              <!--  <header class="slds-modal__header">
                   <lightning:buttonIcon iconName="utility:close" class="slds-modal__close" size="large" variant="bare" alternativeText="Close" onclick="{! c.closeModal }"/>
diff --git a/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.cmp-meta.xml b/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.cmp-meta.xml
index 00776f484..7633fb136 100755
--- a/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.cmp-meta.xml
+++ b/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.cmp-meta.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <AuraDefinitionBundle xmlns="http://soap.sforce.com/2006/04/metadata">
-    <apiVersion>48.0</apiVersion>
-    <description>A Lightning Component Bundle</description>
+    <apiVersion>65.0</apiVersion>
+    <description>Detect and Launch Flow - Automatically detects record changes and launches screen flows based on configurable triggers</description>
 </AuraDefinitionBundle>
\ No newline at end of file
diff --git a/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.css b/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.css
index f407185c1..e397466fb 100755
--- a/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.css
+++ b/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.css
@@ -1,2 +1,36 @@
 .THIS {
 }
+
+/* Responsive modal container */
+.THIS .slds-modal-container {
+    position: relative;
+    width: 100%;
+    height: 100%;
+}
+
+/* Responsive modal sizing */
+.THIS .slds-modal__container--responsive {
+    max-width: 90vw;
+    max-height: 90vh;
+    width: auto;
+    min-width: 20rem;
+}
+
+/* Ensure modal content is scrollable if needed */
+.THIS .slds-modal__content {
+    max-height: calc(90vh - 8rem);
+    overflow-y: auto;
+}
+
+/* Responsive adjustments for smaller screens */
+@media (max-width: 48rem) {
+    .THIS .slds-modal__container--responsive {
+        max-width: 95vw;
+        max-height: 95vh;
+        margin: 0.5rem;
+    }
+    
+    .THIS .slds-modal__content {
+        max-height: calc(95vh - 6rem);
+    }
+}
diff --git a/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.svg b/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.svg
index e201ae9e9..564b1da9b 100755
--- a/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.svg
+++ b/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunch.svg
@@ -1,7 +1,23 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
 <svg width="120px" height="120px" viewBox="0 0 120 120" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
 	<g stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
-		<path d="M120,108 C120,114.6 114.6,120 108,120 L12,120 C5.4,120 0,114.6 0,108 L0,12 C0,5.4 5.4,0 12,0 L108,0 C114.6,0 120,5.4 120,12 L120,108 L120,108 Z" id="Shape" fill="#2A739E" />
-		<path d="M77.7383308,20 L61.1640113,20 L44.7300055,63.2000173 L56.0543288,63.2000173 L40,99.623291 L72.7458388,54.5871812 L60.907727,54.5871812 L77.7383308,20 Z" id="Path-1" fill="#FFFFFF" />
+		<!-- Background -->
+		<path d="M120,108 C120,114.6 114.6,120 108,120 L12,120 C5.4,120 0,114.6 0,108 L0,12 C0,5.4 5.4,0 12,0 L108,0 C114.6,0 120,5.4 120,12 L120,108 Z" id="Shape" fill="#0176D3"/>
+		
+		<!-- Detection/Radar circle -->
+		<circle cx="40" cy="40" r="18" stroke="#FFFFFF" stroke-width="2.5" fill="none" opacity="0.9"/>
+		<circle cx="40" cy="40" r="12" stroke="#FFFFFF" stroke-width="2" fill="none" opacity="0.7"/>
+		<circle cx="40" cy="40" r="6" fill="#FFFFFF" opacity="0.9"/>
+		
+		<!-- Detection indicator dot -->
+		<circle cx="52" cy="28" r="4" fill="#FFB75D"/>
+		
+		<!-- Arrow/Launch indicator -->
+		<path d="M70,40 L95,40 M85,30 L95,40 L85,50" stroke="#FFFFFF" stroke-width="3" stroke-linecap="round" stroke-linejoin="round" fill="none"/>
+		
+		<!-- Flow symbol (curved path) -->
+		<path d="M50,70 Q70,85 90,70" stroke="#FFFFFF" stroke-width="2.5" fill="none" stroke-linecap="round"/>
+		<path d="M50,70 L55,65 M50,70 L55,75" stroke="#FFFFFF" stroke-width="2.5" stroke-linecap="round"/>
+		<path d="M90,70 L85,65 M90,70 L85,75" stroke="#FFFFFF" stroke-width="2.5" stroke-linecap="round"/>
 	</g>
-</svg>
\ No newline at end of file
+</svg>
diff --git a/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunchController.js b/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunchController.js
index 669865a2f..e4f9d7cf4 100755
--- a/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunchController.js
+++ b/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunchController.js
@@ -1,4 +1,10 @@
 ({
+    /**
+     * Initializes the component by setting up the field list for recordData to watch
+     * @param {Component} component - The component instance
+     * @param {Object} event - The init event
+     * @param {Object} helper - The component helper
+     */
     doInit: function(component, event, helper) {
         // By Default set the Id field as this is required
         var tempFieldList = ['Id'];
@@ -13,16 +19,34 @@
         component.set("v.fieldNameList", tempFieldList);
     },
 
+    /**
+     * Opens the modal dialog for flow execution
+     * @param {Component} component - The component instance
+     * @param {Object} event - The event that triggered this action
+     * @param {Object} helper - The component helper
+     */
     openModal : function(component, event, helper) {
 		component.set('v.openModal',true);
 	},
  
+    /**
+     * Closes the modal dialog
+     * @param {Component} component - The component instance
+     * @param {Object} event - The event that triggered this action
+     * @param {Object} helper - The component helper
+     */
 	closeModal : function(component, event, helper) {
 		component.set('v.openModal',false);
 	},
  
 
 
+    /**
+     * Handles flow status change events and closes modal when flow finishes
+     * @param {Component} component - The component instance
+     * @param {Object} event - The flow status change event
+     * @param {Object} helper - The component helper
+     */
     flowStatusChange : function( component, event, helper ) {
         if ( event.getParam( "status" ).indexOf( "FINISHED" ) !== -1 ) {
             component.set( "v.openModal", false );
@@ -30,33 +54,44 @@
         }
     },
     
+    /**
+     * Handles record update events from force:recordData
+     * Determines which flow to launch based on change type and field conditions
+     * @param {Component} component - The component instance
+     * @param {Object} event - The record update event from force:recordData
+     * @param {Object} helper - The component helper
+     */
     recordUpdated: function(component, event, helper) {
-        console.log('entering recordUpdate');
+        helper.debugLog(component, 'entering recordUpdate');
         var eventParams = event.getParams();
 
-        // If both Field Change and Field Value are not null then set to isChangedRecord to true
-        // This will then populate the users field value within the fields list
-        if(component.get("v.fieldChange") != null && component.get("v.fieldValue") != null ){
-            component.set("v.isChangedRecord", true);
-            console.log('fieldChange',component.get("v.fieldChange"));
-            console.log('fieldValue',component.get("v.fieldValue"));
-            // Make sure there was an edited field and we just edited a record
-            if ( eventParams.changedFields && eventParams.changeType === "CHANGED") {
-                console.log('eventParams.changedFields', eventParams.changedFields);
-                var changed = JSON.parse(JSON.stringify(eventParams.changedFields));
-                //console.log('changed', changed);
-                //console.log('changed.dynamic', changed[component.get("v.fieldCompare")]);
-                if (changed[component.get("v.fieldCompare")]) {
-                    console.log('changed.dynamic.value', changed[component.get("v.fieldCompare")].value);
-                    if ( changed[component.get("v.fieldCompare")].value.toString() === component.get("v.fieldValue") ) {
-                        //console.log('hit');
-                        component.set("v.targetFlowName", component.get("v.editFlowName"));
-                        helper.processChangeEvent(component, eventParams);
-                    }
-                }
+        // Check if field conditions are configured
+        var fieldChange = component.get("v.fieldChange");
+        var fieldValue = component.get("v.fieldValue");
+        var fieldConditionsConfigured = (fieldChange !== null && fieldChange !== undefined && 
+                                         fieldValue !== null && fieldValue !== undefined);
+
+        // Field conditions only apply to CHANGED events
+        // For REMOVED and LOADED events, proceed with normal flow launching logic
+        if (fieldConditionsConfigured && eventParams.changeType === "CHANGED") {
+            // Field conditions are configured and this is a CHANGED event - check if value matches
+            if (helper.checkFieldValueMatch(component, eventParams)) {
+                component.set("v.isChangedRecord", true);
+                helper.debugLog(component, 'fieldChange', fieldChange);
+                helper.debugLog(component, 'fieldValue', fieldValue);
+                helper.debugLog(component, 'eventParams.changedFields', eventParams.changedFields);
+                
+                // Field value matches, launch the edit flow
+                component.set("v.targetFlowName", component.get("v.editFlowName"));
+                helper.processChangeEvent(component, eventParams);
+            } else {
+                // Field conditions are configured but value doesn't match - don't launch any flow
+                helper.debugLog(component, 'Field conditions configured but value does not match - skipping flow launch');
+                return;
             }
         } else {
-            console.log('changeType: ' + eventParams.changeType);
+            // No field conditions configured OR this is REMOVED/LOADED event - proceed with normal flow launching logic
+            helper.debugLog(component, `changeType: ${eventParams.changeType}`);
             // Get Flow To Use
             if(eventParams.changeType === "CHANGED") {
                 component.set("v.targetFlowName", component.get("v.editFlowName"));
@@ -66,15 +101,15 @@
                 component.set("v.targetFlowName", component.get("v.loadFlowName"));
             }
 
-
             // Launch Flow
             if(eventParams.changeType === "CHANGED" || eventParams.changeType === "REMOVED") {
                 helper.processChangeEvent(component, eventParams);
             } else if( eventParams.changeType === "LOADED")  {
                 helper.processChangeEvent(component, eventParams);
             } else if(eventParams.changeType === "ERROR") {
-                console.log(eventParams);
-                console.log('Update event received Error: ' + component.get("v.error"));
+                // Show error toast to user
+                var errorMessage = component.get("v.error") || component.get("v.recordError") || 'An error occurred while loading the record.';
+                helper.showErrorToast(component, 'Record Error', errorMessage);
             }
         }
     }
diff --git a/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunchHelper.js b/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunchHelper.js
index 3af16e436..d9905261f 100755
--- a/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunchHelper.js
+++ b/lightning_page_components/DetectAndLaunch/force-app/main/default/aura/detectAndLaunch/detectAndLaunchHelper.js
@@ -1,38 +1,131 @@
 ({
+    /**
+     * Debug logging helper - only logs if debugMode is enabled
+     * @param {Component} component - The component instance
+     * @param {String} message - Message to log
+     * @param {*} data - Optional data to log
+     */
+    debugLog: function(component, message, data) {
+        if (component.get("v.debugMode")) {
+            if (data !== undefined) {
+                console.log(message, data);
+            } else {
+                console.log(message);
+            }
+        }
+    },
+
+    /**
+     * Shows an error toast notification to the user
+     * @param {Component} component - The component instance
+     * @param {String} title - Title of the error toast
+     * @param {String} message - Error message to display
+     */
+    showErrorToast: function(component, title, message) {
+        var notifLib = component.find("notifLib");
+        if (notifLib) {
+            notifLib.showToast({
+                "title": title || "Error",
+                "message": message,
+                "variant": "error",
+                "mode": "sticky"
+            });
+        }
+        // Also log to console for debugging
+        console.error(title + ":", message);
+    },
+
+    /**
+     * Checks if a field value matches the expected value when a record is changed
+     * @param {Component} component - The component instance
+     * @param {Object} eventParams - Event parameters from force:recordData
+     * @returns {Boolean} - True if field value matches, false otherwise
+     */
+    checkFieldValueMatch: function(component, eventParams) {
+        var fieldChange = component.get("v.fieldChange");
+        var fieldValue = component.get("v.fieldValue");
+        
+        // Check if both fieldChange and fieldValue are configured
+        if (fieldChange === null || fieldChange === undefined || 
+            fieldValue === null || fieldValue === undefined) {
+            return false;
+        }
+
+        // Only check field values on CHANGED events
+        if (eventParams.changeType !== "CHANGED") {
+            return false;
+        }
+
+        // Check if changedFields exists
+        if (!eventParams.changedFields) {
+            return false;
+        }
+
+        // Get the field data from changed fields
+        var changed = JSON.parse(JSON.stringify(eventParams.changedFields));
+        var fieldKey = component.get("v.fieldCompare");
+        var fieldData = changed[fieldKey];
+
+        // Check if field exists and has a non-null, non-undefined value
+        if (!fieldData || fieldData.value === null || fieldData.value === undefined) {
+            return false;
+        }
+
+        // Compare the field value
+        var newValue = fieldData.value.toString();
+        this.debugLog(component, 'changed.dynamic.value', newValue);
+        
+        return newValue === fieldValue;
+    },
+
+    /**
+     * Processes record change events and launches appropriate flows
+     * Prevents execution in page builder mode and routes to appropriate launch method
+     * @param {Component} component - The component instance
+     * @param {Object} eventParams - Event parameters from force:recordData
+     * @param {String} eventParams.changeType - Type of change: CHANGED, REMOVED, or LOADED
+     */
     processChangeEvent : function(component, eventParams) {
-        console.log('entering processChangeEvent');
+        this.debugLog(component, 'entering processChangeEvent');
         // Get current URL 
         // If URL contains flexipageEditor do nothing
         var currentUrl = window.location.href;
-        console.log('currentUrl is: ' + currentUrl);
+        this.debugLog(component, `currentUrl is: ${currentUrl}`);
         if (currentUrl.includes('flexipageEditor')) {
-            console.log('currentUrl includes flexipageEditor');
+            this.debugLog(component, 'currentUrl includes flexipageEditor');
             return;
         } else {
             if(eventParams.changeType === "CHANGED") {
-                console.log ('changeType is: ' + eventParams.changeType);
+                this.debugLog(component, `changeType is: ${eventParams.changeType}`);
                 this.callFlow(component, eventParams);
             }  else if(eventParams.changeType === "REMOVED") {
-                console.log('record is being deleted');
+                this.debugLog(component, 'record is being deleted');
                 //the other launch paths don't work well when the underlying page is deleted
-                var targetUrl = '/flow/' + component.get("v.targetFlowName") + '?recordId=' + component.get("v.recordId"); //added input variable
-                console.log('targetURL is: ' + targetUrl);
+                var targetUrl = `/flow/${component.get("v.targetFlowName")}?recordId=${component.get("v.recordId")}`;
+                this.debugLog(component, `targetURL is: ${targetUrl}`);
                 window.open(targetUrl);
             } else if(eventParams.changeType === "LOADED") {
-                console.log ('changeType is: ' + eventParams.changeType);
+                this.debugLog(component, `changeType is: ${eventParams.changeType}`);
                 this.callFlow(component, eventParams);
             }
         }
     },
 
+    /**
+     * Launches a flow in either modal or modeless mode based on launchMode setting
+     * Handles both console and standard UI navigation
+     * @param {Component} component - The component instance
+     * @param {Object} eventParams - Event parameters from force:recordData
+     * @param {String} eventParams.changeType - Type of change: CHANGED, REMOVED, or LOADED
+     */
     callFlow : function(component, eventParams) {
-        console.log('entering callFlow');
-        console.log ('changeType is: ' + eventParams.changeType);
+        this.debugLog(component, 'entering callFlow');
+        this.debugLog(component, `changeType is: ${eventParams.changeType}`);
         var flowApiName = component.get("v.targetFlowName");
-        if (flowApiName == null || flowApiName == undefined) {
-            console.log('flowApiName is null or undefined');
+        if (!flowApiName) {
+            this.debugLog(component, 'flowApiName is null or undefined');
         } else {
-            if(component.get("v.launchMode") == 'Modal') {
+            if(component.get("v.launchMode") === 'Modal') {
                 component.set('v.openModal',true);
 
                 //Set input variable
@@ -45,24 +138,44 @@
                 ];
 
                 var flow = component.find("flow");
-                // Check to see if flow is not null before calling startFlow
-                if (flowApiName != null && flowApiName != undefined) {
-                    console.log('flow is not null', flowApiName);
-                    flow.startFlow(flowApiName, inputVariable); //added input variable
+                // Check to see if flow component exists and flowApiName is valid before calling startFlow
+                if (flow && flowApiName) {
+                    this.debugLog(component, 'Starting flow:', flowApiName);
+                    try {
+                        flow.startFlow(flowApiName, inputVariable);
+                    } catch (error) {
+                        // Show error toast to user
+                        var errorMessage = error.message || 'An error occurred while starting the flow.';
+                        this.showErrorToast(component, 'Flow Error', 
+                            `Unable to start flow "${flowApiName}". ${errorMessage}`);
+                        // Close modal if flow fails to start
+                        component.set('v.openModal', false);
+                    }
                 } else {
-                    console.log('flow is null', flow);
+                    // Show error toast to user
+                    if (!flow) {
+                        this.showErrorToast(component, 'Configuration Error', 
+                            'Flow component not found. Please contact your administrator.');
+                    }
+                    if (!flowApiName) {
+                        this.showErrorToast(component, 'Configuration Error', 
+                            'Flow name is missing or invalid. Please check the component configuration.');
+                    }
+                    // Close modal if we can't start the flow
+                    component.set('v.openModal', false);
                 }
 
             } else {
                 //launch modelessly in a tab or browser window
                 var workspaceAPI = component.find("workspace");
+                var self = this;
                 workspaceAPI.isConsoleNavigation().then(function(response) {
-                    console.log('current workspace is console? : ' + response);
+                    self.debugLog(component, `current workspace is console? : ${response}`);
                     if (response) {
                         //we are in console mode
                         workspaceAPI.getFocusedTabInfo()
                         .then(function(response) {
-                            var targetUrl = '/flow/' + component.get("v.targetFlowName") + '?recordId=' + component.get("v.recordId"); //added input variable;
+                            var targetUrl = `/flow/${component.get("v.targetFlowName")}?recordId=${component.get("v.recordId")}`;
                             workspaceAPI.openSubtab({
                                 parentTabId: response.tabId,
                                 url:  targetUrl,
@@ -71,12 +184,14 @@
             
                         })
                         .catch(function(error) {
-                            console.log(error);
+                            // Show error toast to user
+                            self.showErrorToast(component, 'Navigation Error', 
+                                'Unable to open flow in console. Please try again.');
                         });
                     } else {
-                        console.log('need to launch flow a different way');
-                        var targetUrl = '/flow/' + component.get("v.targetFlowName") + '?recordId=' + component.get("v.recordId"); //added input variable;
-                        console.log('targetURL is: ' + targetUrl);
+                        self.debugLog(component, 'need to launch flow a different way');
+                        var targetUrl = `/flow/${component.get("v.targetFlowName")}?recordId=${component.get("v.recordId")}`;
+                        self.debugLog(component, `targetURL is: ${targetUrl}`);
                         window.open(targetUrl);
                     }
                 })