open-metadata · yan-3005 · Mar 20, 2026 · Mar 25, 2026 · Mar 27, 2026 · Mar 27, 2026
diff --git a/bootstrap/sql/migrations/native/1.13.0/mysql/schemaChanges.sql b/bootstrap/sql/migrations/native/1.13.0/mysql/schemaChanges.sql
@@ -130,6 +130,15 @@ FROM user_entity ue, role_entity re
 WHERE ue.name = 'mcpapplicationbot'
   AND re.name = 'ApplicationBotImpersonationRole';
 
+-- Add composite index on change_event(entityType, offset) for efficient incremental
+-- change-event-driven workflow processing (filters by entityType + offset range).
+CREATE INDEX idx_change_event_entity_type_offset ON change_event (entityType, `offset`);
+
+-- Widen change_event_consumers.id from VARCHAR(36) to VARCHAR(500) to support workflow consumer IDs
+-- which follow the pattern {workflowFQN}Trigger-{entityType} and can exceed 36 characters.
+-- VARCHAR(500) keeps the composite UNIQUE(id, extension) key within MySQL's 3072-byte limit
+-- (500 * 4 + 256 * 4 = 3024 bytes with utf8mb4).
+ALTER TABLE change_event_consumers MODIFY COLUMN id VARCHAR(500) NOT NULL;
 
 UPDATE entity_extension
 SET json = JSON_SET(

diff --git a/bootstrap/sql/migrations/native/1.13.0/postgres/schemaChanges.sql b/bootstrap/sql/migrations/native/1.13.0/postgres/schemaChanges.sql
@@ -151,6 +151,13 @@ WHERE ue.name = 'mcpapplicationbot'
   AND re.name = 'ApplicationBotImpersonationRole'
 ON CONFLICT DO NOTHING;
 
+-- Add composite index on change_event(entityType, offset) for efficient incremental
+-- change-event-driven workflow processing (filters by entityType + offset range).
+CREATE INDEX IF NOT EXISTS idx_change_event_entity_type_offset ON change_event (entitytype, "offset");
+
+-- Widen change_event_consumers.id from VARCHAR(36) to VARCHAR(500) to support workflow consumer IDs
+-- which follow the pattern {workflowFQN}Trigger-{entityType} and can exceed 36 characters.
+ALTER TABLE change_event_consumers ALTER COLUMN id TYPE VARCHAR(500);
 -- Migrate profiler sampling config: move flat profileSample/profileSampleType/samplingMethodType
 -- into the new profileSampleConfig structure. Default to STATIC since DYNAMIC is new.
 

diff --git a/...tegration-tests/src/test/java/org/openmetadata/it/tests/WorkflowDefinitionResourceIT.java b/...tegration-tests/src/test/java/org/openmetadata/it/tests/WorkflowDefinitionResourceIT.java
diff --git a/openmetadata-service/src/main/java/org/openmetadata/service/Entity.java b/openmetadata-service/src/main/java/org/openmetadata/service/Entity.java
@@ -33,6 +33,7 @@
 import java.util.EnumMap;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
@@ -652,6 +653,37 @@ public static <T> T getEntity(EntityLink link, String fields, Include include) {
     return getEntityByName(link.getEntityType(), link.getEntityFQN(), fields, include);
   }
 
+  public static Map<String, EntityInterface> getEntitiesByLinks(
+      List<String> entityLinkStrs, String fields, Include include) {
+    if (entityLinkStrs == null || entityLinkStrs.isEmpty()) {
+      return Map.of();
+    }
+    // All entity links in a workflow's entityList are always the same entity type —
+    // event-based triggers fire for a single entity, and periodic batch triggers are configured
+    // with one entity type. The type is taken from the first link.
+    Map<String, String> linkToFqn = new LinkedHashMap<>();
+    String entityType = null;
+    for (String linkStr : entityLinkStrs) {
+      EntityLink link = EntityLink.parse(linkStr);
+      if (entityType == null) entityType = link.getEntityType();
+      linkToFqn.put(linkStr, link.getEntityFQN());
+    }
-    // All entity links in a workflow's entityList are always the same entity type —
-    // event-based triggers fire for a single entity, and periodic batch triggers are configured
-    // with one entity type. The type is taken from the first link.
-    Map<String, String> linkToFqn = new LinkedHashMap<>();
-    String entityType = null;
-    for (String linkStr : entityLinkStrs) {
-      EntityLink link = EntityLink.parse(linkStr);
-      if (entityType == null) entityType = link.getEntityType();
-      linkToFqn.put(linkStr, link.getEntityFQN());
-    }
+    // All entity links in a workflow's entityList are expected to be the same entity type.
+    // Malformed links are skipped so one bad item does not fail the entire batch, while
+    // mixed entity types are rejected explicitly because getEntityByNames works on one type.
+    Map<String, String> linkToFqn = new LinkedHashMap<>();
+    String entityType = null;
+    for (String linkStr : entityLinkStrs) {
+      try {
+        EntityLink link = EntityLink.parse(linkStr);
+        if (entityType == null) {
+          entityType = link.getEntityType();
+        } else if (!entityType.equals(link.getEntityType())) {
+          throw new BadRequestException(
+              String.format(
+                  "All entity links must have the same entity type. Expected '%s' but found '%s' for link '%s'.",
+                  entityType, link.getEntityType(), linkStr));
+        }
+        linkToFqn.put(linkStr, link.getEntityFQN());
+      } catch (RuntimeException e) {
+        LOG.warn("Skipping malformed entity link [{}]", linkStr, e);
+      }
+    }
+    if (linkToFqn.isEmpty()) {
+      return Map.of();
+    }
-    // All entity links in a workflow's entityList are always the same entity type —
-    // event-based triggers fire for a single entity, and periodic batch triggers are configured
-    // with one entity type. The type is taken from the first link.
-    Map<String, String> linkToFqn = new LinkedHashMap<>();
-    String entityType = null;
-    for (String linkStr : entityLinkStrs) {
-      EntityLink link = EntityLink.parse(linkStr);
-      if (entityType == null) entityType = link.getEntityType();
-      linkToFqn.put(linkStr, link.getEntityFQN());
-    }
+    // All entity links in a workflow's entityList are expected to be the same entity type.
+    // Malformed links are skipped so one bad item does not fail the entire batch, while
+    // mixed entity types are rejected explicitly because getEntityByNames works on one type.
+    Map<String, String> linkToFqn = new LinkedHashMap<>();
+    String entityType = null;
+    for (String linkStr : entityLinkStrs) {
+      try {
+        EntityLink link = EntityLink.parse(linkStr);
+        if (entityType == null) {
+          entityType = link.getEntityType();
+        } else if (!entityType.equals(link.getEntityType())) {
+          throw new BadRequestException(
+              String.format(
+                  "All entity links must have the same entity type. Expected '%s' but found '%s' for link '%s'.",
+                  entityType, link.getEntityType(), linkStr));
+        }
+        linkToFqn.put(linkStr, link.getEntityFQN());
+      } catch (RuntimeException e) {
+        LOG.warn("Skipping malformed entity link [{}]", linkStr, e);
+      }
+    }
+    if (linkToFqn.isEmpty()) {
+      return Map.of();
+    }
+    List<EntityInterface> entities =
+        getEntityByNames(entityType, new ArrayList<>(linkToFqn.values()), fields, include);
+    Map<String, EntityInterface> fqnToEntity = new HashMap<>();
+    for (EntityInterface entity : entities) {
+      fqnToEntity.put(entity.getFullyQualifiedName(), entity);
+    }
+    Map<String, EntityInterface> result = new LinkedHashMap<>();
+    for (Map.Entry<String, String> entry : linkToFqn.entrySet()) {
+      EntityInterface entity = fqnToEntity.get(entry.getValue());
+      if (entity != null) {
+        result.put(entry.getKey(), entity);
-    // All entity links in a workflow's entityList are always the same entity type —
-    // event-based triggers fire for a single entity, and periodic batch triggers are configured
-    // with one entity type. The type is taken from the first link.
-    Map<String, String> linkToFqn = new LinkedHashMap<>();
-    String entityType = null;
-    for (String linkStr : entityLinkStrs) {
-      EntityLink link = EntityLink.parse(linkStr);
-      if (entityType == null) entityType = link.getEntityType();
-      linkToFqn.put(linkStr, link.getEntityFQN());
-    }
-    List<EntityInterface> entities =
-        getEntityByNames(entityType, new ArrayList<>(linkToFqn.values()), fields, include);
-    Map<String, EntityInterface> fqnToEntity = new HashMap<>();
-    for (EntityInterface entity : entities) {
-      fqnToEntity.put(entity.getFullyQualifiedName(), entity);
-    }
-    Map<String, EntityInterface> result = new LinkedHashMap<>();
-    for (Map.Entry<String, String> entry : linkToFqn.entrySet()) {
-      EntityInterface entity = fqnToEntity.get(entry.getValue());
-      if (entity != null) {
-        result.put(entry.getKey(), entity);
+    // Parse all links defensively and allow mixed entity types. A single malformed
+    // link should not abort processing of the whole list.
+    Map<String, EntityLink> linkStrToLink = new LinkedHashMap<>();
+    for (String linkStr : entityLinkStrs) {
+      if (linkStr == null) {
+        LOG.warn("Skipping null entity link string");
+        continue;
+      }
+      try {
+        EntityLink link = EntityLink.parse(linkStr);
+        linkStrToLink.put(linkStr, link);
+      } catch (IllegalArgumentException | BadRequestException ex) {
+        LOG.warn("Skipping invalid entity link '{}': {}", linkStr, ex.getMessage());
+      }
+    }
+    if (linkStrToLink.isEmpty()) {
+      return Map.of();
+    }
+
+    // Group FQNs by entity type so we can fetch them in batches per type.
+    Map<String, List<String>> entityTypeToFqns = new LinkedHashMap<>();
+    for (EntityLink link : linkStrToLink.values()) {
+      entityTypeToFqns
+          .computeIfAbsent(link.getEntityType(), k -> new ArrayList<>())
+          .add(link.getEntityFQN());
+    }
+
+    Map<String, EntityInterface> fqnToEntity = new HashMap<>();
+    for (Map.Entry<String, List<String>> entry : entityTypeToFqns.entrySet()) {
+      String entityType = entry.getKey();
+      List<String> fqns = entry.getValue();
+      if (fqns.isEmpty()) {
+        continue;
+      }
+      List<EntityInterface> entitiesForType =
+          getEntityByNames(entityType, fqns, fields, include);
+      for (EntityInterface entity : entitiesForType) {
+        if (entity != null && entity.getFullyQualifiedName() != null) {
+          fqnToEntity.put(entity.getFullyQualifiedName(), entity);
+        }
+      }
+    }
+
+    Map<String, EntityInterface> result = new LinkedHashMap<>();
+    for (Map.Entry<String, EntityLink> entry : linkStrToLink.entrySet()) {
+      String linkStr = entry.getKey();
+      EntityLink link = entry.getValue();
+      EntityInterface entity = fqnToEntity.get(link.getEntityFQN());
+      if (entity != null) {
+        result.put(linkStr, entity);
-    // All entity links in a workflow's entityList are always the same entity type —
-    // event-based triggers fire for a single entity, and periodic batch triggers are configured
-    // with one entity type. The type is taken from the first link.
-    Map<String, String> linkToFqn = new LinkedHashMap<>();
-    String entityType = null;
-    for (String linkStr : entityLinkStrs) {
-      EntityLink link = EntityLink.parse(linkStr);
-      if (entityType == null) entityType = link.getEntityType();
-      linkToFqn.put(linkStr, link.getEntityFQN());
-    }
-    List<EntityInterface> entities =
-        getEntityByNames(entityType, new ArrayList<>(linkToFqn.values()), fields, include);
-    Map<String, EntityInterface> fqnToEntity = new HashMap<>();
-    for (EntityInterface entity : entities) {
-      fqnToEntity.put(entity.getFullyQualifiedName(), entity);
-    }
-    Map<String, EntityInterface> result = new LinkedHashMap<>();
-    for (Map.Entry<String, String> entry : linkToFqn.entrySet()) {
-      EntityInterface entity = fqnToEntity.get(entry.getValue());
-      if (entity != null) {
-        result.put(entry.getKey(), entity);
+    // Parse all links defensively and allow mixed entity types. A single malformed
+    // link should not abort processing of the whole list.
+    Map<String, EntityLink> linkStrToLink = new LinkedHashMap<>();
+    for (String linkStr : entityLinkStrs) {
+      if (linkStr == null) {
+        LOG.warn("Skipping null entity link string");
+        continue;
+      }
+      try {
+        EntityLink link = EntityLink.parse(linkStr);
+        linkStrToLink.put(linkStr, link);
+      } catch (IllegalArgumentException | BadRequestException ex) {
+        LOG.warn("Skipping invalid entity link '{}': {}", linkStr, ex.getMessage());
+      }
+    }
+    if (linkStrToLink.isEmpty()) {
+      return Map.of();
+    }
+
+    // Group FQNs by entity type so we can fetch them in batches per type.
+    Map<String, List<String>> entityTypeToFqns = new LinkedHashMap<>();
+    for (EntityLink link : linkStrToLink.values()) {
+      entityTypeToFqns
+          .computeIfAbsent(link.getEntityType(), k -> new ArrayList<>())
+          .add(link.getEntityFQN());
+    }
+
+    Map<String, EntityInterface> fqnToEntity = new HashMap<>();
+    for (Map.Entry<String, List<String>> entry : entityTypeToFqns.entrySet()) {
+      String entityType = entry.getKey();
+      List<String> fqns = entry.getValue();
+      if (fqns.isEmpty()) {
+        continue;
+      }
+      List<EntityInterface> entitiesForType =
+          getEntityByNames(entityType, fqns, fields, include);
+      for (EntityInterface entity : entitiesForType) {
+        if (entity != null && entity.getFullyQualifiedName() != null) {
+          fqnToEntity.put(entity.getFullyQualifiedName(), entity);
+        }
+      }
+    }
+
+    Map<String, EntityInterface> result = new LinkedHashMap<>();
+    for (Map.Entry<String, EntityLink> entry : linkStrToLink.entrySet()) {
+      String linkStr = entry.getKey();
+      EntityLink link = entry.getValue();
+      EntityInterface entity = fqnToEntity.get(link.getEntityFQN());
+      if (entity != null) {
+        result.put(linkStr, entity);
+      }
+    }
-    Map<String, String> linkToFqn = new LinkedHashMap<>();
-    String entityType = null;
-    for (String linkStr : entityLinkStrs) {
-      EntityLink link = EntityLink.parse(linkStr);
-      if (entityType == null) entityType = link.getEntityType();
-      linkToFqn.put(linkStr, link.getEntityFQN());
-    }
-    List<EntityInterface> entities =
-        getEntityByNames(entityType, new ArrayList<>(linkToFqn.values()), fields, include);
-    Map<String, EntityInterface> fqnToEntity = new HashMap<>();
-    for (EntityInterface entity : entities) {
-      fqnToEntity.put(entity.getFullyQualifiedName(), entity);
-    }
-    Map<String, EntityInterface> result = new LinkedHashMap<>();
-    for (Map.Entry<String, String> entry : linkToFqn.entrySet()) {
-      EntityInterface entity = fqnToEntity.get(entry.getValue());
-      if (entity != null) {
-        result.put(entry.getKey(), entity);
-      }
-    }
+
+    // Group links by entity type and handle parse failures per-link.
+    Map<String, Map<String, String>> typeToLinkToFqn = new LinkedHashMap<>();
+    for (String linkStr : entityLinkStrs) {
+      if (linkStr == null) {
+        continue;
+      }
+      try {
+        EntityLink link = EntityLink.parse(linkStr);
+        String entityType = link.getEntityType();
+        String entityFqn = link.getEntityFQN();
+        typeToLinkToFqn
+            .computeIfAbsent(entityType, k -> new LinkedHashMap<>())
+            .put(linkStr, entityFqn);
+      } catch (RuntimeException e) {
+        // Skip malformed links but continue processing other links.
+        log.warn("Failed to parse entity link '{}'", linkStr, e);
+      }
+    }
+
+    if (typeToLinkToFqn.isEmpty()) {
+      // No valid links parsed.
+      return Map.of();
+    }
+
+    Map<String, EntityInterface> fqnToEntity = new HashMap<>();
+    for (Map.Entry<String, Map<String, String>> entry : typeToLinkToFqn.entrySet()) {
+      String entityType = entry.getKey();
+      Map<String, String> linkToFqn = entry.getValue();
+      if (linkToFqn.isEmpty()) {
+        continue;
+      }
+      List<EntityInterface> entities =
+          getEntityByNames(entityType, new ArrayList<>(linkToFqn.values()), fields, include);
+      for (EntityInterface entity : entities) {
+        if (entity != null && entity.getFullyQualifiedName() != null) {
+          fqnToEntity.put(entity.getFullyQualifiedName(), entity);
+        }
+      }
+    }
+
+    Map<String, EntityInterface> result = new LinkedHashMap<>();
+    for (Map.Entry<String, Map<String, String>> typeEntry : typeToLinkToFqn.entrySet()) {
+      Map<String, String> linkToFqn = typeEntry.getValue();
+      for (Map.Entry<String, String> linkEntry : linkToFqn.entrySet()) {
+        EntityInterface entity = fqnToEntity.get(linkEntry.getValue());
+        if (entity != null) {
+          result.put(linkEntry.getKey(), entity);
+        }
+      }
+    }
-    Map<String, String> linkToFqn = new LinkedHashMap<>();
-    String entityType = null;
-    for (String linkStr : entityLinkStrs) {
-      EntityLink link = EntityLink.parse(linkStr);
-      if (entityType == null) entityType = link.getEntityType();
-      linkToFqn.put(linkStr, link.getEntityFQN());
-    }
-    List<EntityInterface> entities =
-        getEntityByNames(entityType, new ArrayList<>(linkToFqn.values()), fields, include);
-    Map<String, EntityInterface> fqnToEntity = new HashMap<>();
-    for (EntityInterface entity : entities) {
-      fqnToEntity.put(entity.getFullyQualifiedName(), entity);
-    }
-    Map<String, EntityInterface> result = new LinkedHashMap<>();
-    for (Map.Entry<String, String> entry : linkToFqn.entrySet()) {
-      EntityInterface entity = fqnToEntity.get(entry.getValue());
-      if (entity != null) {
-        result.put(entry.getKey(), entity);
-      }
-    }
+
+    // Group links by entity type and handle parse failures per-link.
+    Map<String, Map<String, String>> typeToLinkToFqn = new LinkedHashMap<>();
+    for (String linkStr : entityLinkStrs) {
+      if (linkStr == null) {
+        continue;
+      }
+      try {
+        EntityLink link = EntityLink.parse(linkStr);
+        String entityType = link.getEntityType();
+        String entityFqn = link.getEntityFQN();
+        typeToLinkToFqn
+            .computeIfAbsent(entityType, k -> new LinkedHashMap<>())
+            .put(linkStr, entityFqn);
+      } catch (RuntimeException e) {
+        // Skip malformed links but continue processing other links.
+        log.warn("Failed to parse entity link '{}'", linkStr, e);
+      }
+    }
+
+    if (typeToLinkToFqn.isEmpty()) {
+      // No valid links parsed.
+      return Map.of();
+    }
+
+    Map<String, EntityInterface> fqnToEntity = new HashMap<>();
+    for (Map.Entry<String, Map<String, String>> entry : typeToLinkToFqn.entrySet()) {
+      String entityType = entry.getKey();
+      Map<String, String> linkToFqn = entry.getValue();
+      if (linkToFqn.isEmpty()) {
+        continue;
+      }
+      List<EntityInterface> entities =
+          getEntityByNames(entityType, new ArrayList<>(linkToFqn.values()), fields, include);
+      for (EntityInterface entity : entities) {
+        if (entity != null && entity.getFullyQualifiedName() != null) {
+          fqnToEntity.put(entity.getFullyQualifiedName(), entity);
+        }
+      }
+    }
+
+    Map<String, EntityInterface> result = new LinkedHashMap<>();
+    for (Map.Entry<String, Map<String, String>> typeEntry : typeToLinkToFqn.entrySet()) {
+      Map<String, String> linkToFqn = typeEntry.getValue();
+      for (Map.Entry<String, String> linkEntry : linkToFqn.entrySet()) {
+        EntityInterface entity = fqnToEntity.get(linkEntry.getValue());
+        if (entity != null) {
+          result.put(linkEntry.getKey(), entity);
+        }
+      }
+    }
+    return result;
+  }
+
   /** Retrieve the entity using id from given entity reference and fields */
   public static <T> T getEntity(
       String entityType, UUID id, String fields, Include include, boolean fromCache) {

diff --git a/...src/main/java/org/openmetadata/service/config/CrossOriginEmbedderPolicyHeaderFactory.java b/...src/main/java/org/openmetadata/service/config/CrossOriginEmbedderPolicyHeaderFactory.java
@@ -0,0 +1,41 @@
+/*
+ *  Copyright 2021 Collate
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package org.openmetadata.service.config;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import java.util.Collections;
+import java.util.Map;
+import org.openmetadata.service.config.web.HeaderFactory;
+
+public class CrossOriginEmbedderPolicyHeaderFactory extends HeaderFactory {
+  public static final String CROSS_ORIGIN_EMBEDDER_POLICY_HEADER = "Cross-Origin-Embedder-Policy";
+
+  @JsonProperty("option")
+  private String option;
+
+  public CrossOriginEmbedderPolicyHeaderFactory() {}
+
+  public String getOption() {
+    return this.option;
+  }
+
+  public void setOption(String option) {
+    this.option = option;
+  }
+
+  @Override
+  protected Map<String, String> buildHeaders() {
+    return Collections.singletonMap(CROSS_ORIGIN_EMBEDDER_POLICY_HEADER, this.option);
+  }
+}
diff --git a/...e/src/main/java/org/openmetadata/service/config/CrossOriginOpenerPolicyHeaderFactory.java b/...e/src/main/java/org/openmetadata/service/config/CrossOriginOpenerPolicyHeaderFactory.java
@@ -0,0 +1,41 @@
+/*
+ *  Copyright 2021 Collate
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package org.openmetadata.service.config;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import java.util.Collections;
+import java.util.Map;
+import org.openmetadata.service.config.web.HeaderFactory;
+
+public class CrossOriginOpenerPolicyHeaderFactory extends HeaderFactory {
+  public static final String CROSS_ORIGIN_OPENER_POLICY_HEADER = "Cross-Origin-Opener-Policy";
+
+  @JsonProperty("option")
+  private String option;
+
+  public CrossOriginOpenerPolicyHeaderFactory() {}
+
+  public String getOption() {
+    return this.option;
+  }
+
+  public void setOption(String option) {
+    this.option = option;
+  }
+
+  @Override
+  protected Map<String, String> buildHeaders() {
+    return Collections.singletonMap(CROSS_ORIGIN_OPENER_POLICY_HEADER, this.option);
+  }
+}
diff --git a/...src/main/java/org/openmetadata/service/config/CrossOriginResourcePolicyHeaderFactory.java b/...src/main/java/org/openmetadata/service/config/CrossOriginResourcePolicyHeaderFactory.java
@@ -0,0 +1,41 @@
+/*
+ *  Copyright 2021 Collate
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package org.openmetadata.service.config;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import java.util.Collections;
+import java.util.Map;
+import org.openmetadata.service.config.web.HeaderFactory;
+
+public class CrossOriginResourcePolicyHeaderFactory extends HeaderFactory {
+  public static final String CROSS_ORIGIN_RESOURCE_POLICY_HEADER = "Cross-Origin-Resource-Policy";
+
+  @JsonProperty("option")
+  private String option;
+
+  public CrossOriginResourcePolicyHeaderFactory() {}
+
+  public String getOption() {
+    return this.option;
+  }
+
+  public void setOption(String option) {
+    this.option = option;
+  }
+
+  @Override
+  protected Map<String, String> buildHeaders() {
+    return Collections.singletonMap(CROSS_ORIGIN_RESOURCE_POLICY_HEADER, this.option);
+  }
+}
diff --git a/...etadata-service/src/main/java/org/openmetadata/service/governance/workflows/Workflow.java b/...etadata-service/src/main/java/org/openmetadata/service/governance/workflows/Workflow.java
@@ -1,5 +1,7 @@
 package org.openmetadata.service.governance.workflows;
 
+import io.github.resilience4j.retry.RetryConfig;
+import java.time.Duration;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import org.openmetadata.schema.governance.workflows.WorkflowDefinition;
@@ -12,6 +14,8 @@ public class Workflow {
   public static final String INGESTION_PIPELINE_ID_VARIABLE = "ingestionPipelineId";
   public static final String RELATED_ENTITY_VARIABLE = "relatedEntity";
   public static final String ENTITY_LIST_VARIABLE = "entityList";
+  public static final String TRUE_ENTITY_LIST_VARIABLE = "true_entityList";
+  public static final String FALSE_ENTITY_LIST_VARIABLE = "false_entityList";
   public static final String BATCH_SINK_PROCESSED_VARIABLE = "batchSinkProcessed";
   public static final String TRIGGERING_OBJECT_ID_VARIABLE = "triggeringObjectId";
   public static final String RECOGNIZER_FEEDBACK = "recognizerFeedback";
@@ -26,6 +30,12 @@ public class Workflow {
   public static final String GLOBAL_NAMESPACE = "global";
   public static final String SUCCESSFUL_RESULT = "success";
   public static final String FAILURE_RESULT = "failure";
+  public static final RetryConfig TASK_RETRY_CONFIG =
+      RetryConfig.custom()
+          .maxAttempts(3)
+          .waitDuration(Duration.ofMillis(500))
+          .retryExceptions(Exception.class)
+          .build();
   private final TriggerWorkflow triggerWorkflow;
   private final MainWorkflow mainWorkflow;
   private final WorkflowDefinition workflowDefinition;

diff --git a/...ce/src/main/java/org/openmetadata/service/governance/workflows/WorkflowEventConsumer.java b/...ce/src/main/java/org/openmetadata/service/governance/workflows/WorkflowEventConsumer.java
@@ -1,9 +1,9 @@
 package org.openmetadata.service.governance.workflows;
 
 import static org.openmetadata.schema.entity.events.SubscriptionDestination.SubscriptionType.GOVERNANCE_WORKFLOW_CHANGE_EVENT;
+import static org.openmetadata.service.governance.workflows.Workflow.ENTITY_LIST_VARIABLE;
 import static org.openmetadata.service.governance.workflows.Workflow.GLOBAL_NAMESPACE;
 import static org.openmetadata.service.governance.workflows.Workflow.RECOGNIZER_FEEDBACK;
-import static org.openmetadata.service.governance.workflows.Workflow.RELATED_ENTITY_VARIABLE;
 import static org.openmetadata.service.governance.workflows.Workflow.TRIGGERING_OBJECT_ID_VARIABLE;
 import static org.openmetadata.service.governance.workflows.Workflow.UPDATED_BY_VARIABLE;
 import static org.openmetadata.service.governance.workflows.WorkflowVariableHandler.getNamespacedVariableName;
@@ -229,9 +229,10 @@ public static Map<String, Object> defaultHandler(ChangeEvent event) {
       MessageParser.EntityLink entityLink =
           new MessageParser.EntityLink(entityType, entityReference.getFullyQualifiedName());
 
+      String entityLinkString = entityLink.getLinkString();
       variables.put(
-          getNamespacedVariableName(GLOBAL_NAMESPACE, RELATED_ENTITY_VARIABLE),
-          entityLink.getLinkString());
+          getNamespacedVariableName(GLOBAL_NAMESPACE, ENTITY_LIST_VARIABLE),
+          List.of(entityLinkString));
 
       // Set the updatedBy variable from the change event userName
       if (event.getUserName() != null) {
@@ -257,9 +258,10 @@ private static Map<String, Object> handleTagRecognizerFeedback(ChangeEvent event
     MessageParser.EntityLink entityLink =
         new MessageParser.EntityLink(Entity.TAG, entityReference.getFullyQualifiedName());
 
+    String entityLinkString = entityLink.getLinkString();
     variables.put(
-        getNamespacedVariableName(GLOBAL_NAMESPACE, RELATED_ENTITY_VARIABLE),
-        entityLink.getLinkString());
+        getNamespacedVariableName(GLOBAL_NAMESPACE, ENTITY_LIST_VARIABLE),
+        List.of(entityLinkString));
 
     variables.put(
         getNamespacedVariableName(GLOBAL_NAMESPACE, TRIGGERING_OBJECT_ID_VARIABLE),

diff --git a/...-service/src/main/java/org/openmetadata/service/governance/workflows/WorkflowHandler.java b/...-service/src/main/java/org/openmetadata/service/governance/workflows/WorkflowHandler.java
@@ -18,7 +18,6 @@
 import java.util.Set;
 import java.util.UUID;
 import javax.sql.DataSource;
-import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import org.flowable.bpmn.converter.BpmnXMLConverter;
 import org.flowable.common.engine.api.FlowableObjectNotFoundException;
@@ -73,7 +72,7 @@ public class WorkflowHandler {
   private ProcessEngine processEngine;
   private final Map<Object, Object> expressionMap = new HashMap<>();
   private static WorkflowHandler instance;
-  @Getter private static volatile boolean initialized = false;
+  private static volatile boolean initialized = false;
   private final boolean isMigrationContext;
 
   private WorkflowHandler(OpenMetadataApplicationConfig config, boolean isMigrationContext) {
@@ -265,6 +264,10 @@ public static WorkflowHandler getInstance() {
     throw new UnhandledServerException("WorkflowHandler is not initialized.");
   }
 
+  public static boolean isInitialized() {
+    return initialized;
+  }
+
   public ProcessEngineConfiguration getProcessEngineConfiguration() {
     if (processEngine != null) {
       return processEngine.getProcessEngineConfiguration();

diff --git a/.../openmetadata/service/governance/workflows/WorkflowInstanceExecutionIdSetterListener.java b/.../openmetadata/service/governance/workflows/WorkflowInstanceExecutionIdSetterListener.java
@@ -1,7 +1,5 @@
 package org.openmetadata.service.governance.workflows;
 
-import static org.openmetadata.service.governance.workflows.Workflow.GLOBAL_NAMESPACE;
-import static org.openmetadata.service.governance.workflows.Workflow.RELATED_ENTITY_VARIABLE;
 import static org.openmetadata.service.governance.workflows.Workflow.WORKFLOW_INSTANCE_EXECUTION_ID_VARIABLE;
 import static org.openmetadata.service.governance.workflows.WorkflowHandler.getProcessDefinitionKeyFromId;
 
@@ -17,47 +15,12 @@ public void execute(DelegateExecution execution) {
     String workflowName = getProcessDefinitionKeyFromId(execution.getProcessDefinitionId());
     String processInstanceId = execution.getProcessInstanceId();
 
-    // CRITICAL: Always set the execution ID first - this is mandatory for stage tracking
     UUID workflowInstanceExecutionId = UUID.randomUUID();
     execution.setVariable(WORKFLOW_INSTANCE_EXECUTION_ID_VARIABLE, workflowInstanceExecutionId);
     LOG.debug(
         "[WORKFLOW_EXEC_ID_SET] Workflow: {}, ProcessInstance: {}, ExecutionId: {} - Execution ID initialized",
         workflowName,
         processInstanceId,
         workflowInstanceExecutionId);
-
-    WorkflowVariableHandler varHandler = new WorkflowVariableHandler(execution);
-    try {
-      String relatedEntity =
-          (String) varHandler.getNamespacedVariable(GLOBAL_NAMESPACE, RELATED_ENTITY_VARIABLE);
-
-      if (relatedEntity == null || relatedEntity.isEmpty()) {
-        LOG.error(
-            "[WORKFLOW_MISSING_ENTITY] Workflow: {}, ProcessInstance: {}, ExecutionId: {} - RELATED_ENTITY variable is null/empty. Workflow will likely fail.",
-            workflowName,
-            processInstanceId,
-            workflowInstanceExecutionId);
-        execution.setVariable(Workflow.FAILURE_VARIABLE, true);
-        execution.setVariable("startupError", "Missing required variable: relatedEntity");
-      } else {
-        LOG.debug(
-            "[WORKFLOW_EXEC_STARTED] Workflow: {}, ProcessInstance: {}, ExecutionId: {}, RelatedEntity: {} - Workflow execution initialized successfully",
-            workflowName,
-            processInstanceId,
-            workflowInstanceExecutionId,
-            relatedEntity);
-      }
-    } catch (Exception exc) {
-      LOG.error(
-          "[WORKFLOW_INIT_ERROR] Workflow: {}, ProcessInstance: {}, ExecutionId: {} - Failed to retrieve relatedEntity variable. Error: {}",
-          workflowName,
-          processInstanceId,
-          workflowInstanceExecutionId,
-          exc.getMessage(),
-          exc);
-      // Set failure indicator but don't prevent workflow from starting
-      execution.setVariable(Workflow.FAILURE_VARIABLE, true);
-      execution.setVariable("startupError", "Failed to get relatedEntity: " + exc.getMessage());
-    }
   }
 }