diff --git a/ui/web-v2/src/components/FeatureConfirmDialog/index.tsx b/ui/web-v2/src/components/FeatureConfirmDialog/index.tsx
index 551109477a..cbf234e0be 100644
--- a/ui/web-v2/src/components/FeatureConfirmDialog/index.tsx
+++ b/ui/web-v2/src/components/FeatureConfirmDialog/index.tsx
@@ -53,7 +53,7 @@ interface FeatureConfirmDialogProps {
   title: string;
   description: string;
   displayResetSampling?: boolean;
-  isSwitchEnabledConfirm?: boolean;
+  // isSwitchEnabledConfirm?: boolean;
   isEnabled?: boolean;
   isArchive?: boolean;
   featureId?: string;
@@ -78,7 +78,7 @@ export const FeatureConfirmDialog: FC<FeatureConfirmDialogProps> = ({
   title,
   description,
   displayResetSampling,
-  isSwitchEnabledConfirm,
+  // isSwitchEnabledConfirm,
   isEnabled,
   isArchive,
   featureId,
@@ -91,12 +91,12 @@ export const FeatureConfirmDialog: FC<FeatureConfirmDialogProps> = ({
   const history = useHistory();
   const [flagList, setFlagList] = useState([]);
   const [isFlagActive, setIsFlagActive] = useState(false);
-  const [selectedSwitchEnabledType, setSelectedSwitchEnabledType] = useState(
-    isEnabled ? SwitchEnabledType.DISABLE_NOW : SwitchEnabledType.ENABLE_NOW
-  );
+  // const [selectedSwitchEnabledType, setSelectedSwitchEnabledType] = useState(
+  //   isEnabled ? SwitchEnabledType.DISABLE_NOW : SwitchEnabledType.ENABLE_NOW
+  // );
 
   const [saveFeatureType, setSaveFeatureType] = useState(
-    SaveFeatureType.SCHEDULE
+    SaveFeatureType.UPDATE_NOW
   );
   const [scheduleErrorMessage, setScheduleErrorMessage] = useState('');
 
@@ -133,14 +133,14 @@ export const FeatureConfirmDialog: FC<FeatureConfirmDialogProps> = ({
   }, []);
 
   useEffect(() => {
-    if (isSwitchEnabledConfirm && isEnabled) {
-      dispatch(
-        listProgressiveRollout({
-          featureId: featureId,
-          environmentId: currentEnvironment.id
-        })
-      );
-    }
+    // if (isSwitchEnabledConfirm && isEnabled) {
+    dispatch(
+      listProgressiveRollout({
+        featureId: featureId,
+        environmentId: currentEnvironment.id
+      })
+    );
+    // }
   }, []);
 
   useEffect(() => {
@@ -200,44 +200,44 @@ export const FeatureConfirmDialog: FC<FeatureConfirmDialogProps> = ({
     }
   }, [isArchive, open, feature]);
 
-  const getSubmitBtnLabel = () => {
-    if (isSwitchEnabledConfirm) {
-      return selectedSwitchEnabledType === SwitchEnabledType.ENABLE_NOW
-        ? f(messages.button.enable)
-        : selectedSwitchEnabledType === SwitchEnabledType.DISABLE_NOW
-          ? f(messages.button.disable)
-          : f(messages.button.schedule);
-    }
-    return f(messages.button.submit);
-  };
+  // const getSubmitBtnLabel = () => {
+  //   if (isSwitchEnabledConfirm) {
+  //     return selectedSwitchEnabledType === SwitchEnabledType.ENABLE_NOW
+  //       ? f(messages.button.enable)
+  //       : selectedSwitchEnabledType === SwitchEnabledType.DISABLE_NOW
+  //         ? f(messages.button.disable)
+  //         : f(messages.button.schedule);
+  //   }
+  //   return f(messages.button.submit);
+  // };
 
-  const handleScheduleSubmit = () => {
-    const command = new CreateAutoOpsRuleCommand();
-    command.setFeatureId(featureId);
-    const clause = new DatetimeClause();
-    command.setOpsType(OpsType.SCHEDULE);
-    if (isEnabled) {
-      clause.setActionType(ActionType.DISABLE);
-    } else {
-      clause.setActionType(ActionType.ENABLE);
-    }
-    clause.setTime(Math.round(datetime.getTime() / 1000));
-    command.setDatetimeClausesList([clause]);
-    dispatch(
-      createAutoOpsRule({
-        environmentId: currentEnvironment.id,
-        command: command
-      })
-    ).then(() => {
-      dispatch(
-        addToast({
-          message: f(messages.feature.successMessages.schedule),
-          severity: 'success'
-        })
-      );
-      onClose();
-    });
-  };
+  // const handleScheduleSubmit = () => {
+  //   const command = new CreateAutoOpsRuleCommand();
+  //   command.setFeatureId(featureId);
+  //   const clause = new DatetimeClause();
+  //   command.setOpsType(OpsType.SCHEDULE);
+  //   if (isEnabled) {
+  //     clause.setActionType(ActionType.DISABLE);
+  //   } else {
+  //     clause.setActionType(ActionType.ENABLE);
+  //   }
+  //   clause.setTime(Math.round(datetime.getTime() / 1000));
+  //   command.setDatetimeClausesList([clause]);
+  //   dispatch(
+  //     createAutoOpsRule({
+  //       environmentId: currentEnvironment.id,
+  //       command: command
+  //     })
+  //   ).then(() => {
+  //     dispatch(
+  //       addToast({
+  //         message: f(messages.feature.successMessages.schedule),
+  //         severity: 'success'
+  //       })
+  //     );
+  //     onClose();
+  //   });
+  // };
 
   // const handleScheduleSubmit = () => {
   //   const command = new CreateAutoOpsRuleCommand();
@@ -269,7 +269,8 @@ export const FeatureConfirmDialog: FC<FeatureConfirmDialogProps> = ({
 
   const checkSubmitBtnDisabled = () => {
     if (
-      selectedSwitchEnabledType === SwitchEnabledType.SCHEDULE &&
+      // selectedSwitchEnabledType === SwitchEnabledType.SCHEDULE &&
+      saveFeatureType === SaveFeatureType.SCHEDULE &&
       !scheduleErrorMessage
     ) {
       return false;
@@ -281,7 +282,7 @@ export const FeatureConfirmDialog: FC<FeatureConfirmDialogProps> = ({
     <Modal
       open={open}
       onClose={onClose}
-      overflowVisible={isSwitchEnabledConfirm}
+      // overflowVisible={isSwitchEnabledConfirm}
     >
       <Dialog.Title
         as="h3"
@@ -340,65 +341,63 @@ export const FeatureConfirmDialog: FC<FeatureConfirmDialogProps> = ({
           </div>
         </div>
       )}
-      {selectedSwitchEnabledType !== SwitchEnabledType.SCHEDULE && (
-        <div className="mt-5">
-          <div className="flex items-center space-x-1">
-            <label
-              htmlFor="updateComment"
-              className="block text-sm font-medium text-gray-700"
-            >
-              {f(messages.feature.updateComment)}
-            </label>
-            <label
-              htmlFor="required/optional"
-              className="block text-sm text-gray-500"
-            >
-              {currentEnvironment.requireComment
-                ? f(messages.input.required)
-                : f(messages.input.optional)}
-            </label>
-          </div>
-          <div className="mt-1">
-            <textarea
-              {...register('comment', {
-                maxLength: FEATURE_UPDATE_COMMENT_MAX_LENGTH
-              })}
-              id="comment"
-              rows={3}
-              className="input-text w-full"
-              disabled={flagList.length > 0}
+      <div className="mt-5">
+        <div className="flex items-center space-x-1">
+          <label
+            htmlFor="updateComment"
+            className="block text-sm font-medium text-gray-700"
+          >
+            {f(messages.feature.updateComment)}
+          </label>
+          <label
+            htmlFor="required/optional"
+            className="block text-sm text-gray-500"
+          >
+            {currentEnvironment.requireComment
+              ? f(messages.input.required)
+              : f(messages.input.optional)}
+          </label>
+        </div>
+        <div className="mt-1">
+          <textarea
+            {...register('comment', {
+              maxLength: FEATURE_UPDATE_COMMENT_MAX_LENGTH
+            })}
+            id="comment"
+            rows={3}
+            className="input-text w-full"
+            disabled={flagList.length > 0}
+          />
+          <p className="input-error">
+            {errors.comment && (
+              <span role="alert">{errors.comment.message}</span>
+            )}
+          </p>
+        </div>
+        {displayResetSampling && (
+          <div className="mt-3 flex space-x-2 items-center">
+            <Controller
+              name="resetSampling"
+              control={control}
+              render={({ field }) => {
+                return (
+                  <CheckBox
+                    id="resample"
+                    value={'resample'}
+                    onChange={(_: string, checked: boolean): void =>
+                      field.onChange(checked)
+                    }
+                    defaultChecked={false}
+                  />
+                );
+              }}
             />
-            <p className="input-error">
-              {errors.comment && (
-                <span role="alert">{errors.comment.message}</span>
-              )}
-            </p>
+            <label htmlFor="resample" className={classNames('input-label')}>
+              {f(messages.feature.resetRandomSampling)}
+            </label>
           </div>
-          {displayResetSampling && (
-            <div className="mt-3 flex space-x-2 items-center">
-              <Controller
-                name="resetSampling"
-                control={control}
-                render={({ field }) => {
-                  return (
-                    <CheckBox
-                      id="resample"
-                      value={'resample'}
-                      onChange={(_: string, checked: boolean): void =>
-                        field.onChange(checked)
-                      }
-                      defaultChecked={false}
-                    />
-                  );
-                }}
-              />
-              <label htmlFor="resample" className={classNames('input-label')}>
-                {f(messages.feature.resetRandomSampling)}
-              </label>
-            </div>
-          )}
-        </div>
-      )}
+        )}
+      </div>
       {/* {isSwitchEnabledConfirm && (
         <div className="mt-4 space-y-2">
           <div className="flex items-center space-x-2">
@@ -495,46 +494,48 @@ export const FeatureConfirmDialog: FC<FeatureConfirmDialogProps> = ({
           </div>
         </div>
       )} */}
-      {isSwitchEnabledConfirm &&
+      {
+        // isSwitchEnabledConfirm &&
         isEnabled &&
-        progressiveRollout.find((p) =>
-          isProgressiveRolloutsRunningWaiting(p.status)
-        ) && (
-          <div className="bg-yellow-50 p-4 mt-4">
-            <div className="flex">
-              <div className="flex-shrink-0">
-                <ExclamationIcon
-                  className="h-5 w-5 text-yellow-400"
-                  aria-hidden="true"
-                />
-              </div>
-              <div className="ml-3">
-                <p className="text-sm text-yellow-700">
-                  {f(
-                    messages.autoOps.progressiveRolloutWarningMessages
-                      .progressiveRolloutInProgress,
-                    {
-                      link: (
-                        <span
-                          onClick={() => {
-                            history.push(
-                              `${PAGE_PATH_ROOT}${currentEnvironment.urlCode}${PAGE_PATH_FEATURES}/${featureId}${PAGE_PATH_FEATURE_AUTOOPS}`
-                            );
-                          }}
-                          className="underline text-primary cursor-pointer ml-1"
-                        >
-                          <span>
-                            {f(messages.sourceType.progressiveRollout)}
+          progressiveRollout.find((p) =>
+            isProgressiveRolloutsRunningWaiting(p.status)
+          ) && (
+            <div className="bg-yellow-50 p-4 mt-4">
+              <div className="flex">
+                <div className="flex-shrink-0">
+                  <ExclamationIcon
+                    className="h-5 w-5 text-yellow-400"
+                    aria-hidden="true"
+                  />
+                </div>
+                <div className="ml-3">
+                  <p className="text-sm text-yellow-700">
+                    {f(
+                      messages.autoOps.progressiveRolloutWarningMessages
+                        .progressiveRolloutInProgress,
+                      {
+                        link: (
+                          <span
+                            onClick={() => {
+                              history.push(
+                                `${PAGE_PATH_ROOT}${currentEnvironment.urlCode}${PAGE_PATH_FEATURES}/${featureId}${PAGE_PATH_FEATURE_AUTOOPS}`
+                              );
+                            }}
+                            className="underline text-primary cursor-pointer ml-1"
+                          >
+                            <span>
+                              {f(messages.sourceType.progressiveRollout)}
+                            </span>
                           </span>
-                        </span>
-                      )
-                    }
-                  )}
-                </p>
+                        )
+                      }
+                    )}
+                  </p>
+                </div>
               </div>
             </div>
-          </div>
-        )}
+          )
+      }
       {!isArchive && (
         <div className="mt-4 space-y-2">
           <div className="flex items-center space-x-2">
@@ -624,7 +625,7 @@ export const FeatureConfirmDialog: FC<FeatureConfirmDialogProps> = ({
             }}
           >
             {/* {getSubmitBtnLabel()} */}
-            Save
+            {f(messages.button.save)}
           </button>
         </div>
       </div>
diff --git a/ui/web-v2/src/modules/features.ts b/ui/web-v2/src/modules/features.ts
index 864c3617a1..59d9fb7433 100644
--- a/ui/web-v2/src/modules/features.ts
+++ b/ui/web-v2/src/modules/features.ts
@@ -346,135 +346,38 @@ export const updateFeature = createAsyncThunk<
   console.log('params', params);
 
   if (params.enabled !== undefined) {
+    console.log('Enabled set');
     request.setEnabled(new BoolValue().setValue(params.enabled));
   }
 
   if (params.prerequisitesList) {
     console.log('pre-requisites set');
-    const prerequisiteList = params.prerequisitesList.map((prerequisite) => {
-      const p = new Prerequisite();
-      p.setFeatureId(prerequisite.featureId);
-      p.setVariationId(prerequisite.variationId);
-      return p;
-    });
-    const prerequisiteListValue = new PrerequisiteListValue();
-    prerequisiteListValue.setValuesList(prerequisiteList);
-    request.setPrerequisites(prerequisiteListValue);
+    request.setPrerequisites(mapToPrerequisites(params.prerequisitesList));
   }
 
   if (params.targets) {
     console.log('targets');
-    const targets = params.targets.map((target) => {
-      console.log({ target });
-      const t = new Target();
-      t.setVariation(target.variationId);
-      t.setUsersList(target.users);
-      return t;
-    });
-    const targetsListValue = new TargetListValue();
-    targetsListValue.setValuesList(targets);
-    request.setTargets(targetsListValue);
+    request.setTargets(mapToTargets(params.targets));
   }
 
   if (params.rules) {
     console.log('rules');
-    const rules = params.rules.map((rule) => {
-      const r = new Rule();
-
-      const clausesList = rule.clauses.map((clause) => {
-        const c = new Clause();
-        c.setId(clause.id);
-        c.setOperator(clause.operator);
-        c.setAttribute(clause.attribute);
-        c.setValuesList(clause.values);
-        return c;
-      });
-
-      const strategy = new Strategy();
-
-      if (rule.strategy.option.value === Strategy.Type.ROLLOUT.toString()) {
-        console.log('rule rollout strategy');
-        strategy.setType(Strategy.Type.ROLLOUT);
-        const rolloutStrategy = new RolloutStrategy();
-
-        const variationList = rule.strategy.rolloutStrategy.map((rollout) => {
-          const rolloutStrategyVariation = new RolloutStrategy.Variation();
-          rolloutStrategyVariation.setVariation(rollout.id);
-          rolloutStrategyVariation.setWeight(rollout.percentage * 1000);
-          return rolloutStrategyVariation;
-        });
-        rolloutStrategy.setVariationsList(variationList);
-        strategy.setRolloutStrategy(rolloutStrategy);
-      } else {
-        console.log('rule fixed strategy');
-        strategy.setType(Strategy.Type.FIXED);
-        const fixedStrategy = new FixedStrategy();
-        fixedStrategy.setVariation(rule.strategy.option.value);
-
-        strategy.setFixedStrategy(fixedStrategy);
-      }
-
-      r.setId(rule.id);
-      r.setClausesList(clausesList);
-      r.setStrategy(strategy);
-
-      return r;
-    });
-    const rulesListValue = new RuleListValue();
-    rulesListValue.setValuesList(rules);
-    request.setRules(rulesListValue);
+    request.setRules(mapToRules(params.rules));
   }
 
   if (params.defaultStrategy) {
-    const strategy = new Strategy();
-    if (
-      params.defaultStrategy.option.value === Strategy.Type.ROLLOUT.toString()
-    ) {
-      strategy.setType(Strategy.Type.ROLLOUT);
-      console.log('set Default Strategy - Rollout');
-      const rolloutStrategy = new RolloutStrategy();
-
-      const variationList = params.defaultStrategy.rolloutStrategy.map(
-        (rollout) => {
-          const rolloutStrategyVariation = new RolloutStrategy.Variation();
-          rolloutStrategyVariation.setVariation(rollout.id);
-          rolloutStrategyVariation.setWeight(rollout.percentage * 1000);
-          return rolloutStrategyVariation;
-        }
-      );
-      rolloutStrategy.setVariationsList(variationList);
-      strategy.setRolloutStrategy(rolloutStrategy);
-    } else {
-      console.log('set Default Strategy - Fixed');
-      strategy.setType(Strategy.Type.FIXED);
-      const fixedStrategy = new FixedStrategy();
-      fixedStrategy.setVariation(params.defaultStrategy.option.value);
-
-      strategy.setFixedStrategy(fixedStrategy);
-    }
-    request.setDefaultStrategy(strategy);
+    console.log('defaultStrategy set');
+    request.setDefaultStrategy(mapToStrategy(params.defaultStrategy));
   }
 
   if (params.offVariation) {
     console.log('offVariation set');
-    const offVariation = new Variation();
-    offVariation.setValue(params.offVariation.value);
-    request.setOffVariation(offVariation);
+    request.setOffVariation(mapOffVariation(params.offVariation));
   }
 
   if (params.variations) {
     console.log('variations set');
-    const variations = params.variations.map((v) => {
-      const variation = new Variation();
-      variation.setId(v.id);
-      variation.setName(v.name);
-      variation.setValue(v.value);
-      variation.setDescription(v.description);
-      return variation;
-    });
-    const variationListValue = new VariationListValue();
-    variationListValue.setValuesList(variations);
-    request.setVariations(variationListValue);
+    request.setVariations(mapVariations(params.variations));
   }
 
   if (params.name) {
@@ -482,21 +385,123 @@ export const updateFeature = createAsyncThunk<
     request.setName(new StringValue().setValue(params.name));
   }
 
-  if (params.description) {
+  if (params.description !== undefined) {
     console.log('description set');
     request.setDescription(new StringValue().setValue(params.description));
   }
 
   if (params.tags) {
     console.log('tags set');
-    const stringListValue = new StringListValue();
-    stringListValue.setValuesList(params.tags);
-    request.setTags(stringListValue);
+    request.setTags(mapTags(params.tags));
   }
 
   await featureGrpc.updateFeature(request);
 });
 
+function mapToPrerequisites(
+  prerequisitesList: UpdateFeatureParams['prerequisitesList']
+): PrerequisiteListValue {
+  const prerequisiteList = prerequisitesList.map((prerequisite) => {
+    const p = new Prerequisite();
+    p.setFeatureId(prerequisite.featureId);
+    p.setVariationId(prerequisite.variationId);
+    return p;
+  });
+  const prerequisiteListValue = new PrerequisiteListValue();
+  prerequisiteListValue.setValuesList(prerequisiteList);
+  return prerequisiteListValue;
+}
+
+function mapToTargets(
+  targets: UpdateFeatureParams['targets']
+): TargetListValue {
+  const targetList = targets.map((target) => {
+    const t = new Target();
+    t.setVariation(target.variationId);
+    t.setUsersList(target.users);
+    return t;
+  });
+  const targetsListValue = new TargetListValue();
+  targetsListValue.setValuesList(targetList);
+  return targetsListValue;
+}
+
+function mapToStrategy(
+  strategy:
+    | UpdateFeatureParams['defaultStrategy']
+    | UpdateFeatureParams['rules'][number]['strategy']
+): Strategy {
+  const newStrategy = new Strategy();
+  if (strategy.option.value === Strategy.Type.ROLLOUT.toString()) {
+    newStrategy.setType(Strategy.Type.ROLLOUT);
+    const rolloutStrategy = new RolloutStrategy();
+    const variationList =
+      strategy.rolloutStrategy?.map((rollout) => {
+        const rolloutStrategyVariation = new RolloutStrategy.Variation();
+        rolloutStrategyVariation.setVariation(rollout.id);
+        rolloutStrategyVariation.setWeight(rollout.percentage * 1000);
+        return rolloutStrategyVariation;
+      }) || [];
+    rolloutStrategy.setVariationsList(variationList);
+    newStrategy.setRolloutStrategy(rolloutStrategy);
+  } else {
+    newStrategy.setType(Strategy.Type.FIXED);
+    const fixedStrategy = new FixedStrategy();
+    fixedStrategy.setVariation(strategy.option.value);
+    newStrategy.setFixedStrategy(fixedStrategy);
+  }
+  return newStrategy;
+}
+
+function mapToRules(rules: UpdateFeatureParams['rules']): RuleListValue {
+  const ruleList = rules.map((rule) => {
+    const r = new Rule();
+    const clausesList = rule.clauses.map((clause) => {
+      const c = new Clause();
+      c.setId(clause.id);
+      c.setOperator(clause.operator);
+      c.setAttribute(clause.attribute);
+      c.setValuesList(clause.values);
+      return c;
+    });
+    r.setId(rule.id);
+    r.setClausesList(clausesList);
+    r.setStrategy(mapToStrategy(rule.strategy));
+    return r;
+  });
+  const rulesListValue = new RuleListValue();
+  rulesListValue.setValuesList(ruleList);
+  return rulesListValue;
+}
+
+function mapOffVariation(offVariation: UpdateFeatureParams['offVariation']) {
+  const variation = new Variation();
+  variation.setValue(offVariation.value);
+  return variation;
+}
+
+function mapVariations(
+  variations: UpdateFeatureParams['variations']
+): VariationListValue {
+  const variationList = variations.map((v) => {
+    const variation = new Variation();
+    variation.setId(v.id);
+    variation.setName(v.name);
+    variation.setValue(v.value);
+    variation.setDescription(v.description);
+    return variation;
+  });
+  const variationListValue = new VariationListValue();
+  variationListValue.setValuesList(variationList);
+  return variationListValue;
+}
+
+function mapTags(tags: string[]): StringListValue {
+  const stringListValue = new StringListValue();
+  stringListValue.setValuesList(tags);
+  return stringListValue;
+}
+
 export interface UpdateFeatureTargetingParams {
   environmentId: string;
   id: string;
diff --git a/ui/web-v2/src/pages/feature/index.tsx b/ui/web-v2/src/pages/feature/index.tsx
index 8e615a6150..0a5e498929 100644
--- a/ui/web-v2/src/pages/feature/index.tsx
+++ b/ui/web-v2/src/pages/feature/index.tsx
@@ -628,7 +628,7 @@ export const FeatureIndexPage: FC = memo(() => {
         <FormProvider {...switchEnabledMethod}>
           <FeatureConfirmDialog
             featureId={switchEnabledGetValues('featureId')}
-            isSwitchEnabledConfirm={true}
+            // isSwitchEnabledConfirm={true}
             isEnabled={!switchEnabledGetValues('enabled')}
             open={isSwitchEnableConfirmDialogOpen}
             // handleSubmit={() => switchEnableHandleSubmit(handleSwitchEnabled)}
diff --git a/ui/web-v2/src/pages/feature/settings.tsx b/ui/web-v2/src/pages/feature/settings.tsx
index 4d3a9d9cf1..0feb0cfc02 100644
--- a/ui/web-v2/src/pages/feature/settings.tsx
+++ b/ui/web-v2/src/pages/feature/settings.tsx
@@ -89,17 +89,8 @@ export const FeatureSettingsPage: FC<FeatureSettingsPageProps> = memo(
 
     const handleUpdate = useCallback(
       async (data, saveFeatureType) => {
-        if (saveFeatureType === SaveFeatureType.SCHEDULE) {
-          dispatch(
-            updateFeature({
-              environmentId: currentEnvironment.id,
-              id: feature.id,
-              comment: data.comment,
-              name: dirtyFields.name && data.name,
-              description: dirtyFields.description && data.description,
-              tags: dirtyFields.tags && data.tags
-            })
-          ).then(() => {
+        const prepareUpdate = async (updateAction, payload) => {
+          dispatch(updateAction(payload)).then(() => {
             setIsConfirmDialogOpen(false);
             dispatch(
               getFeature({
@@ -116,31 +107,48 @@ export const FeatureSettingsPage: FC<FeatureSettingsPageProps> = memo(
               });
             });
           });
+        };
+
+        if (saveFeatureType === SaveFeatureType.SCHEDULE) {
+          await prepareUpdate(updateFeature, {
+            environmentId: currentEnvironment.id,
+            id: feature.id,
+            comment: data.comment,
+            name: dirtyFields.name ? data.name : undefined,
+            description: dirtyFields.description ? data.description : undefined,
+            tags: dirtyFields.tags ? data.tags : undefined
+          });
         } else {
           const commands: UpdateDetailCommands = {};
+
           if (dirtyFields.name) {
-            commands.renameCommand = new RenameFeatureCommand();
-            commands.renameCommand.setName(data.name);
+            const renameCommand = new RenameFeatureCommand();
+            renameCommand.setName(data.name);
+            commands.renameCommand = renameCommand;
           }
+
           if (dirtyFields.description) {
-            commands.changeDescriptionCommand = new ChangeDescriptionCommand();
-            commands.changeDescriptionCommand.setDescription(data.description);
+            const descriptionCommand = new ChangeDescriptionCommand();
+            descriptionCommand.setDescription(data.description);
+            commands.changeDescriptionCommand = descriptionCommand;
           }
+
           if (dirtyFields.tags) {
             const addTags = data.tags?.filter(
               (tag) => !feature.tagsList.includes(tag)
             );
-            if (addTags.length) {
+            if (addTags?.length) {
               commands.addTagCommands = addTags.map((tag) => {
                 const addTagCommand = new AddTagCommand();
                 addTagCommand.setTag(tag);
                 return addTagCommand;
               });
             }
+
             const removeTags = feature.tagsList.filter(
               (tag) => !data.tags?.includes(tag)
             );
-            if (removeTags.length) {
+            if (removeTags?.length) {
               commands.removeTagCommands = removeTags.map((tag) => {
                 const removeTagCommand = new RemoveTagCommand();
                 removeTagCommand.setTag(tag);
@@ -148,33 +156,16 @@ export const FeatureSettingsPage: FC<FeatureSettingsPageProps> = memo(
               });
             }
           }
-          dispatch(
-            updateFeatureDetails({
-              environmentId: currentEnvironment.id,
-              id: feature.id,
-              comment: data.comment,
-              updateDetailCommands: commands
-            })
-          ).then(() => {
-            setIsConfirmDialogOpen(false);
-            dispatch(
-              getFeature({
-                environmentId: currentEnvironment.id,
-                id: featureId
-              })
-            ).then((res) => {
-              const featurePayload = res.payload as Feature.AsObject;
-              reset({
-                name: featurePayload.name,
-                description: featurePayload.description,
-                tags: featurePayload.tagsList,
-                comment: ''
-              });
-            });
+
+          await prepareUpdate(updateFeatureDetails, {
+            environmentId: currentEnvironment.id,
+            id: feature.id,
+            comment: data.comment,
+            updateDetailCommands: commands
           });
         }
       },
-      [dispatch, dirtyFields]
+      [dispatch, dirtyFields, currentEnvironment, featureId, feature, reset]
     );
 
     if (isLoading) {
diff --git a/ui/web-v2/src/pages/feature/targeting.tsx b/ui/web-v2/src/pages/feature/targeting.tsx
index d5e5293b7a..195ba45096 100644
--- a/ui/web-v2/src/pages/feature/targeting.tsx
+++ b/ui/web-v2/src/pages/feature/targeting.tsx
@@ -90,8 +90,6 @@ export const FeatureTargetingPage: FC<FeatureTargetingPageProps> = memo(
       }
     );
 
-    console.log({ feature });
-
     const getDefaultValues = (
       feature: Feature.AsObject,
       requireComment: boolean
@@ -159,61 +157,8 @@ export const FeatureTargetingPage: FC<FeatureTargetingPageProps> = memo(
 
     const handleUpdate = useCallback(
       async (data, saveFeatureType) => {
-        if (saveFeatureType === SaveFeatureType.SCHEDULE) {
-          // console.log({ dirtyFields });
-
-          // FIXME: Reset sampling not found
-
-          const hasDirtyPrerequisites = dirtyFields.prerequisites?.some(
-            (item) => Object.values(item).includes(true)
-          );
-          const hasDirtyTargets = dirtyFields.targets?.some((item) =>
-            Object.values(item).includes(true)
-          );
-          // const hasDirtyDefaultStrategy =
-          //   dirtyFields.defaultStrategy &&
-          //   ((typeof dirtyFields.defaultStrategy.option === 'boolean' &&
-          //     dirtyFields.defaultStrategy.option === true) ||
-          //     (typeof dirtyFields.defaultStrategy.option === 'object' &&
-          //       Object.values(dirtyFields.defaultStrategy.option).includes(
-          //         true
-          //       )) ||
-          //     dirtyFields.defaultStrategy.rolloutStrategy.some((strategy) =>
-          //       Object.values(strategy).includes(true)
-          //     ));
-
-          const hasDirtyDefaultStrategy =
-            dirtyFields.defaultStrategy &&
-            JSON.stringify(dirtyFields.defaultStrategy).includes('true');
-
-          const hasDirtyOffVariation =
-            dirtyFields.offVariation &&
-            JSON.stringify(dirtyFields.offVariation).includes('true');
-
-          // const hasDirtyOffVariation =
-          //   dirtyFields.offVariation &&
-          //   ((typeof dirtyFields.offVariation === 'boolean' &&
-          //     dirtyFields.offVariation === true) ||
-          //     (typeof dirtyFields.offVariation === 'object' &&
-          //       Object.values(dirtyFields.offVariation).includes(true)));
-
-          const hasDirtyRules =
-            dirtyFields.rules &&
-            JSON.stringify(dirtyFields.rules).includes('true');
-
-          dispatch(
-            updateFeature({
-              environmentId: currentEnvironment.id,
-              id: featureId,
-              comment: data.comment,
-              enabled: dirtyFields.enabled && data.enabled,
-              prerequisitesList: hasDirtyPrerequisites && data.prerequisites,
-              targets: hasDirtyTargets && data.targets,
-              rules: hasDirtyRules && data.rules,
-              defaultStrategy: hasDirtyDefaultStrategy && data.defaultStrategy,
-              offVariation: hasDirtyOffVariation && data.offVariation
-            })
-          ).then(() => {
+        const prepareUpdate = async (actionType, payload) => {
+          dispatch(actionType(payload)).then(() => {
             setIsConfirmDialogOpen(false);
             dispatch(
               getFeature({
@@ -230,6 +175,35 @@ export const FeatureTargetingPage: FC<FeatureTargetingPageProps> = memo(
               );
             });
           });
+        };
+
+        const hasDirtyField = (field) =>
+          field && JSON.stringify(field).includes('true');
+
+        if (saveFeatureType === SaveFeatureType.SCHEDULE) {
+          const hasDirtyPrerequisites = dirtyFields.prerequisites?.some(
+            (item) => Object.values(item).includes(true)
+          );
+          const hasDirtyTargets = dirtyFields.targets?.some((item) =>
+            Object.values(item).includes(true)
+          );
+
+          const updatePayload = {
+            environmentId: currentEnvironment.id,
+            id: featureId,
+            comment: data.comment,
+            enabled: dirtyFields.enabled ? data.enabled : undefined,
+            prerequisitesList: hasDirtyPrerequisites && data.prerequisites,
+            targets: hasDirtyTargets && data.targets,
+            rules: hasDirtyField(dirtyFields.rules) && data.rules,
+            defaultStrategy:
+              hasDirtyField(dirtyFields.defaultStrategy) &&
+              data.defaultStrategy,
+            offVariation:
+              hasDirtyField(dirtyFields.offVariation) && data.offVariation
+          };
+
+          await prepareUpdate(updateFeature, updatePayload);
         } else if (saveFeatureType === SaveFeatureType.UPDATE_NOW) {
           const commands: Array<Command> = [];
           const defaultValues = getDefaultValues(
@@ -276,30 +250,14 @@ export const FeatureTargetingPage: FC<FeatureTargetingPageProps> = memo(
                 data.prerequisites
               )
             );
-          dispatch(
-            updateFeatureTargeting({
-              environmentId: currentEnvironment.id,
-              id: feature.id,
-              comment: data.comment,
-              commands: commands
-            })
-          ).then(() => {
-            setIsConfirmDialogOpen(false);
-            dispatch(
-              getFeature({
-                environmentId: currentEnvironment.id,
-                id: featureId
-              })
-            ).then((response) => {
-              const featurePayload = response.payload as Feature.AsObject;
-              reset(
-                getDefaultValues(
-                  featurePayload,
-                  currentEnvironment.requireComment
-                )
-              );
-            });
-          });
+
+          const updatePayload = {
+            environmentId: currentEnvironment.id,
+            id: featureId,
+            comment: data.comment,
+            commands: commands
+          };
+          await prepareUpdate(updateFeatureTargeting, updatePayload);
         }
       },
       [dispatch, dirtyFields, feature]
@@ -338,7 +296,7 @@ export const FeatureTargetingPage: FC<FeatureTargetingPageProps> = memo(
     // Check if only switch is enabled/disabled or other fields are also changed
     // If only switch is enabled/disabled, then show Enable/Disable now and Schedule radio options in Confirm dialog
     // If other fields are also changed, then hide Enable/Disable now and Schedule radio options in Confirm dialog
-    const isSwitchEnabledConfirm = dirtyFieldsKeys(dirtyFields);
+    // const isSwitchEnabledConfirm = dirtyFieldsKeys(dirtyFields);
 
     return (
       <FormProvider {...methods}>
@@ -357,7 +315,7 @@ export const FeatureTargetingPage: FC<FeatureTargetingPageProps> = memo(
             description={f(messages.feature.confirm.description)}
             displayResetSampling={true}
             featureId={featureId}
-            isSwitchEnabledConfirm={isSwitchEnabledConfirm}
+            // isSwitchEnabledConfirm={isSwitchEnabledConfirm}
             isEnabled={
               dirtyFields.enabled &&
               getDefaultValues(feature, currentEnvironment.requireComment)
diff --git a/ui/web-v2/src/pages/feature/variations.tsx b/ui/web-v2/src/pages/feature/variations.tsx
index ca09d6c369..32aa91b41c 100644
--- a/ui/web-v2/src/pages/feature/variations.tsx
+++ b/ui/web-v2/src/pages/feature/variations.tsx
@@ -80,19 +80,8 @@ export const FeatureVariationsPage: FC<FeatureVariationsPageProps> = memo(
 
     const handleUpdate = useCallback(
       async (data: VariationForm, saveFeatureType) => {
-        if (saveFeatureType === SaveFeatureType.SCHEDULE) {
-          console.log({
-            dirtyFields,
-            data
-          });
-          dispatch(
-            updateFeature({
-              environmentId: currentEnvironment.id,
-              id: feature.id,
-              comment: data.comment,
-              variations: data.variations
-            })
-          ).then(() => {
+        const prepareUpdate = async (actionType, payload) => {
+          dispatch(actionType(payload)).then(() => {
             setIsConfirmDialogOpen(false);
             dispatch(
               getFeature({
@@ -109,43 +98,37 @@ export const FeatureVariationsPage: FC<FeatureVariationsPageProps> = memo(
               });
             });
           });
+        };
+
+        if (saveFeatureType === SaveFeatureType.SCHEDULE) {
+          await prepareUpdate(updateFeature, {
+            environmentId: currentEnvironment.id,
+            id: feature.id,
+            comment: data.comment,
+            variations: data.variations
+          });
         } else {
           const commands: Array<Command> = [];
-          dirtyFields.variations &&
+          if (dirtyFields.variations) {
             commands.push(
               ...createVariationCommands(
                 feature.variationsList,
                 data.variations
               )
             );
-          data.resetSampling && commands.push(createResetSampleSeedCommand());
-          dispatch(
-            updateFeatureVariations({
-              environmentId: currentEnvironment.id,
-              id: feature.id,
-              comment: data.comment,
-              commands: commands
-            })
-          ).then(() => {
-            setIsConfirmDialogOpen(false);
-            dispatch(
-              getFeature({
-                environmentId: currentEnvironment.id,
-                id: featureId
-              })
-            ).then((response) => {
-              const featurePayload = response.payload as Feature.AsObject;
-              reset({
-                variationType: featurePayload.variationType.toString(),
-                variations: featurePayload.variationsList,
-                requireComment: currentEnvironment.requireComment,
-                comment: ''
-              });
-            });
+          }
+          if (data.resetSampling) {
+            commands.push(createResetSampleSeedCommand());
+          }
+          await prepareUpdate(updateFeatureVariations, {
+            environmentId: currentEnvironment.id,
+            id: feature.id,
+            comment: data.comment,
+            commands
           });
         }
       },
-      [feature, dispatch, dirtyFields]
+      [feature, dispatch, dirtyFields, featureId, reset, currentEnvironment]
     );
 
     if (isLoading) {