diff --git a/src/components/ArchivedRoutingModal.vue b/src/components/ArchivedRoutingModal.vue
index a0f2508..2731943 100644
--- a/src/components/ArchivedRoutingModal.vue
+++ b/src/components/ArchivedRoutingModal.vue
@@ -24,7 +24,6 @@
 </template>
 
 <script setup lang="ts">
-import emitter from "@/event-bus";
 import { Route } from "@/types";
 import {
   IonButton,
@@ -41,26 +40,26 @@ import {
 } from "@ionic/vue";
 import { closeOutline } from "ionicons/icons";
 import { defineProps, ref } from "vue";
-import { useStore } from "vuex";
 
-const store = useStore()
 const props = defineProps({
   archivedRoutings: {
     required: true
   }
 })
 
-let routings = ref(props.archivedRoutings)
+let routings = ref(props.archivedRoutings) as any
+let routingsToUpdate = ref([]) as any
 
 function closeModal() {
-  modalController.dismiss({ dismissed: true });
+  modalController.dismiss({ dismissed: true, routings: routingsToUpdate.value.concat(routings.value) });
 }
 
 async function updateOrderRouting(routing: Route, fieldToUpdate: string, value: string) {
-  const orderRoutingId = await store.dispatch("orderRouting/updateOrderRouting", { orderRoutingId: routing.orderRoutingId, fieldToUpdate, value })
-  if(orderRoutingId) {
-    routings.value = (routings.value as any).filter((routing: Route) => routing.orderRoutingId !== orderRoutingId)
-    emitter.emit("initializeOrderRoutings")
-  }
+  routingsToUpdate.value.push({
+    ...routing,
+    [fieldToUpdate]: value
+  })
+  // remove the updated routing from the archivedRoutings
+  routings.value = routings.value.filter((route: Route) => route.orderRoutingId !== routing.orderRoutingId)
 }
 </script>
diff --git a/src/services/RoutingService.ts b/src/services/RoutingService.ts
index 0a25fd8..db4998e 100644
--- a/src/services/RoutingService.ts
+++ b/src/services/RoutingService.ts
@@ -8,7 +8,7 @@ const fetchRoutingGroups = async (payload: any): Promise<any> => {
   });
 }
 
-const fetchRoutingGroup = async (routingGroupId: string): Promise<any> => {
+const fetchRoutingGroupInformation = async (routingGroupId: string): Promise<any> => {
   return api({
     url: `groups/${routingGroupId}`,
     method: "GET"
@@ -31,14 +31,6 @@ const updateRoutingGroup = async (payload: any): Promise<any> => {
   })
 }
 
-const fetchOrderRoutings = async (payload: any): Promise<any> => {
-  return api({
-    url: `groups/${payload.routingGroupId}/routings`,
-    method: "GET",
-    query: payload
-  });
-}
-
 const fetchOrderRouting = async (orderRoutingId: string): Promise<any> => {
   return api({
     url: `routings/${orderRoutingId}`,
@@ -150,9 +142,8 @@ export const OrderRoutingService = {
   deleteRoutingFilter,
   deleteRuleCondition,
   fetchOrderRouting,
-  fetchOrderRoutings,
   fetchRoutingFilters,
-  fetchRoutingGroup,
+  fetchRoutingGroupInformation,
   fetchRoutingGroups,
   fetchRoutingRules,
   fetchRuleActions,
diff --git a/src/store/modules/orderRouting/actions.ts b/src/store/modules/orderRouting/actions.ts
index 550346d..9f4d34a 100644
--- a/src/store/modules/orderRouting/actions.ts
+++ b/src/store/modules/orderRouting/actions.ts
@@ -5,7 +5,8 @@ import { OrderRoutingService } from "@/services/RoutingService"
 import { hasError, showToast, sortSequence } from "@/utils"
 import * as types from './mutation-types'
 import logger from "@/logger"
-import { Route, RouteFilter } from "@/types"
+import { RouteFilter } from "@/types"
+import { DateTime } from "luxon"
 
 const actions: ActionTree<OrderRoutingState, RootState> = {
   async fetchOrderRoutingGroups({ commit }) {
@@ -35,7 +36,8 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
   async createRoutingGroup({ dispatch }, groupName) {
     const payload = {
       groupName,
-      productStoreId: "STORE"
+      productStoreId: "STORE",
+      createdDate: DateTime.now().toMillis()
     }
     try {
       const resp = await OrderRoutingService.createRoutingGroup(payload)
@@ -50,40 +52,11 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
     }
   },
 
-  async updateRoutingGroup({ commit, state }, payload) {
-    const current = JSON.parse(JSON.stringify(state.currentGroup))
-
-    const params = {
-      routingGroupId: payload.routingGroupId,
-      [payload.fieldToUpdate]: payload.value
-    }
+  async fetchCurrentRoutingGroup({ commit }, routingGroupId) {
+    let currentGroup = {} as any
 
     try {
-      const resp = await OrderRoutingService.updateRoutingGroup(params);
-
-      if(!hasError(resp) && resp.data.routingGroupId) {
-        current[payload.fieldToUpdate] = payload.value
-        showToast("Rounting group information updated")
-      } else {
-        throw resp.data
-      }
-    } catch(err) {
-      logger.error(err);
-    }
-    commit(types.ORDER_ROUTING_CURRENT_GROUP_UPDATED, current)
-  },
-
-  async fetchCurrentRoutingGroup({ dispatch, state }, routingGroupId) {
-    const current = state.currentGroup
-    if(current.routingGroupId && current.routingGroupId === routingGroupId) {
-      dispatch("setCurrentRoutingGroup", current)
-      return;
-    }
-
-    let currentGroup = {}
-
-    try {
-      const resp = await OrderRoutingService.fetchRoutingGroup(routingGroupId);
+      const resp = await OrderRoutingService.fetchRoutingGroupInformation(routingGroupId);
 
       if(!hasError(resp) && resp.data) {
         currentGroup = resp.data
@@ -94,41 +67,15 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
       logger.error(err);
     }
 
-    dispatch("setCurrentRoutingGroup", currentGroup)
-  },
-
-  async setCurrentRoutingGroup({ commit }, payload) {
-    commit(types.ORDER_ROUTING_CURRENT_GROUP_UPDATED, payload)
-  },
-
-  async fetchOrderRoutings({ commit }, routingGroupId) {
-    let orderRoutings = [] as any;
-    // filter groups on the basis of productStoreId
-    const payload = {
-      routingGroupId
+    if(currentGroup.routings.length) {
+      currentGroup.routings = sortSequence(currentGroup.routings)
     }
 
-    try {
-      const resp = await OrderRoutingService.fetchOrderRoutings(payload);
-
-      if(!hasError(resp) && resp.data.length) {
-        orderRoutings = resp.data
-      } else {
-        throw resp.data
-      }
-    } catch(err) {
-      logger.error(err);
-    }
-
-    if(orderRoutings.length) {
-      orderRoutings = sortSequence(orderRoutings)
-    }
-
-    commit(types.ORDER_ROUTINGS_UPDATED, orderRoutings)
+    commit(types.ORDER_ROUTING_CURRENT_GROUP_UPDATED, currentGroup)
   },
 
-  async createOrderRouting({ commit, state }, payload) {
-    let orderRoutings = JSON.parse(JSON.stringify(state.routes))
+  async createOrderRouting({ dispatch, state }, payload) {
+    const currentGroup = JSON.parse(JSON.stringify(state.currentGroup))
     let orderRoutingId = ''
 
     try {
@@ -136,19 +83,18 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
 
       if(!hasError(resp) && resp?.data.orderRoutingId) {
         orderRoutingId = resp.data.orderRoutingId
-        orderRoutings.push({
+        currentGroup["routings"].push({
           ...payload,
           orderRoutingId
         })
-        showToast('New Order Routing Created')
+        showToast('New routing created')
       }
 
-      // Sort the routings and update the state only on success
-      if(orderRoutings.length) {
-        orderRoutings = sortSequence(orderRoutings)
+      if(currentGroup["routings"].length) {
+        currentGroup["routings"] = sortSequence(currentGroup["routings"])
       }
 
-      commit(types.ORDER_ROUTINGS_UPDATED, orderRoutings)
+      await dispatch("setCurrentGroup", currentGroup)
     } catch(err) {
       showToast("Failed to create order routing")
       logger.error('err', err)
@@ -157,41 +103,8 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
     return orderRoutingId;
   },
 
-  async updateOrderRouting({ commit, state }, payload) {
-    let orderRoutings = JSON.parse(JSON.stringify(state.routes))
-    const field: Route[keyof Route] = payload.fieldToUpdate
-    let orderRoutingId = ''
-
-    const params = {
-      orderRoutingId: payload.orderRoutingId,
-      [field]: payload.value  // only one field can be updated once for orderRouting
-    }
-
-    try {
-      const resp = await OrderRoutingService.updateOrderRouting(params);
-
-      if(!hasError(resp) && resp.data.orderRoutingId) {
-        orderRoutingId = resp.data.orderRoutingId
-        orderRoutings.map((routing: Route) => {
-          if(routing.orderRoutingId === orderRoutingId) {
-            routing[field] = payload.value
-          }
-        })
-        showToast("Order routing information updated")
-      } else {
-        throw resp.data
-      }
-    } catch(err) {
-      showToast("Failed to update order routing")
-      logger.error(err);
-    }
-
-    if(orderRoutings.length) {
-      orderRoutings = sortSequence(orderRoutings)
-    }
-
-    commit(types.ORDER_ROUTINGS_UPDATED, orderRoutings)
-    return orderRoutingId;
+  async setCurrentGroup({ commit }, currentGroup) {
+    commit(types.ORDER_ROUTING_CURRENT_GROUP_UPDATED, currentGroup)
   },
 
   async fetchCurrentOrderRouting({ dispatch, state }, orderRoutingId) {
diff --git a/src/store/modules/orderRouting/getters.ts b/src/store/modules/orderRouting/getters.ts
index a95480f..b38bfd2 100644
--- a/src/store/modules/orderRouting/getters.ts
+++ b/src/store/modules/orderRouting/getters.ts
@@ -6,9 +6,6 @@ const getters: GetterTree<OrderRoutingState, RootState> = {
   getRoutingGroups(state) {
     return state.groups
   },
-  getOrderRoutings(state) {
-    return state.routes
-  },
   getRoutingRules(state) {
     return JSON.parse(JSON.stringify(state.rules))
   },
diff --git a/src/utils/index.ts b/src/utils/index.ts
index 52856be..acfd9fd 100644
--- a/src/utils/index.ts
+++ b/src/utils/index.ts
@@ -119,6 +119,8 @@ const jsonToCsv = (file: any, options: JsonToCsvOption = {}) => {
 }
 
 const sortSequence = (sequence: Array<Group | Route | Rule>) => {
+  // Currently, sorting is only performed on sequenceNum, so if two seqence have same seqNum then they will be arranged in FCFS basis
+  // TODO: Need to check that if for the above case we need to define the sorting on name as well, when seqNum is same
   return sequence.sort((a, b) => a.sequenceNum - b.sequenceNum)
 }
 
diff --git a/src/views/BrokeringRoute.vue b/src/views/BrokeringRoute.vue
index 3dd0f26..17fb80a 100644
--- a/src/views/BrokeringRoute.vue
+++ b/src/views/BrokeringRoute.vue
@@ -96,7 +96,7 @@
         </section>
       </div>
       <ion-fab vertical="bottom" horizontal="end" slot="fixed">
-        <ion-fab-button :disabled="!routingsToUpdate.length">
+        <ion-fab-button :disabled="!hasUnsavedChanges" @click="saveRoutingGroup">
           <ion-icon :icon="saveOutline" />
         </ion-fab-button>
       </ion-fab>
@@ -107,16 +107,15 @@
 <script setup lang="ts">
 import { IonBackButton, IonBadge, IonButtons, IonButton, IonCard, IonCardHeader, IonCardTitle, IonChip, IonContent, IonFab, IonFabButton, IonHeader, IonIcon, IonItem, IonLabel, IonList, IonListHeader, IonPage, IonReorder, IonReorderGroup, IonSelect, IonSelectOption, IonTextarea, IonTitle, IonToolbar, alertController, modalController, onIonViewWillEnter, onIonViewWillLeave } from "@ionic/vue";
 import { addCircleOutline, archiveOutline, reorderTwoOutline, saveOutline, timerOutline } from "ionicons/icons"
-import { useRouter } from "vue-router";
+import { onBeforeRouteLeave, useRouter } from "vue-router";
 import { useStore } from "vuex";
 import { computed, defineProps, ref } from "vue";
 import { Group, Route } from "@/types";
 import ArchivedRoutingModal from "@/components/ArchivedRoutingModal.vue"
-import emitter from "@/event-bus";
 import { OrderRoutingService } from "@/services/RoutingService";
 import logger from "@/logger";
 import { DateTime } from "luxon";
-import { hasError, showToast } from "@/utils";
+import { hasError, showToast, sortSequence } from "@/utils";
 
 const router = useRouter();
 const store = useStore();
@@ -129,30 +128,55 @@ const props = defineProps({
 
 const routingStatus = JSON.parse(process.env?.VUE_APP_ROUTE_STATUS_ENUMS as string)
 const cronExpressions = JSON.parse(process.env?.VUE_APP_CRON_EXPRESSIONS as string)
-let routingsToUpdate = ref([])
-let initialRoutingsOrder = ref([])
 let routingsForReorder = ref([])
 let description = ref('')
 let isDescUpdating = ref(false)
+let hasUnsavedChanges = ref(false)
 
 let job = ref({}) as any
+let orderRoutings = ref([]) as any
 
 const currentRoutingGroup: any = computed((): Group => store.getters["orderRouting/getCurrentRoutingGroup"])
-const orderRoutings = computed(() => store.getters["orderRouting/getOrderRoutings"])
+const currentEComStore = computed(() => store.getters["user/getCurrentEComStore"])
 
 onIonViewWillEnter(async () => {
-  await Promise.all([store.dispatch("orderRouting/fetchOrderRoutings", props.routingGroupId), store.dispatch("orderRouting/fetchCurrentRoutingGroup", props.routingGroupId)])
-
-  initializeOrderRoutings();
+  await store.dispatch("orderRouting/fetchCurrentRoutingGroup", props.routingGroupId)
 
   job.value = currentRoutingGroup.value["schedule"] ? JSON.parse(JSON.stringify(currentRoutingGroup.value))["schedule"] : {}
-
-  description.value = currentRoutingGroup.value.description ? currentRoutingGroup.value.description : "No description available"
-  emitter.on("initializeOrderRoutings", initializeOrderRoutings)
+  orderRoutings.value = currentRoutingGroup.value["routings"] ? JSON.parse(JSON.stringify(currentRoutingGroup.value))["routings"] : {}
+  description.value = currentRoutingGroup.value["description"] ? currentRoutingGroup.value["description"] : "No description available"
+  
+  initializeOrderRoutings();
 })
 
-onIonViewWillLeave(() => {
-  emitter.off("initializeOrderRoutings", initializeOrderRoutings)
+onBeforeRouteLeave(async (to) => {
+  if(to.path === '/login') return;
+  let canLeave = false;
+
+  const alert = await alertController.create({
+    header: "Leave page",
+    message: "Any edits made on this page will be lost.",
+    buttons: [
+      {
+        text: "STAY",
+        handler: () => {
+          canLeave = false;
+        },
+      },
+      {
+        text: "LEAVE",
+        handler: () => {
+          canLeave = true;
+        },
+      },
+    ],
+  });
+
+  if(hasUnsavedChanges.value) {
+    alert.present();
+    await alert.onDidDismiss();
+    return canLeave;
+  }
 })
 
 function updateCronExpression(event: CustomEvent) {
@@ -164,7 +188,6 @@ function getTime(time: any) {
 }
 
 function initializeOrderRoutings() {
-  initialRoutingsOrder.value = JSON.parse(JSON.stringify(getActiveAndDraftOrderRoutings()))
   routingsForReorder.value = JSON.parse(JSON.stringify(getActiveAndDraftOrderRoutings()))
 }
 
@@ -239,14 +262,16 @@ async function createOrderRoute() {
         routingGroupId: props.routingGroupId,
         statusId: "ROUTING_DRAFT",
         routingName,
-        sequenceNum: orderRoutings.value.length && orderRoutings.value[orderRoutings.value.length - 1].sequenceNum >= 0 ? orderRoutings.value[orderRoutings.value.length - 1].sequenceNum + 5 : 0,  // added check for `>= 0` as sequenceNum can be 0 which will result in again setting the new route seqNum to 0
-        description: ""
+        sequenceNum: orderRoutings.value.length && orderRoutings.value[orderRoutings.value.length - 1].sequenceNum >= 0 ? orderRoutings.value[orderRoutings.value.length - 1].sequenceNum + 5 : 0,  // added check for `>= 0` as sequenceNum can be 0 which will result in again setting the new route seqNum to 0, also considering archivedRouting when calculating new seqNum
+        description: "",
+        createdDate: DateTime.now().toMillis()
       }
 
       const orderRoutingId = await store.dispatch("orderRouting/createOrderRouting", payload)
 
-      // update the routing order for reordering
+      // update the routing order for reordering and the cloned updated routings again
       if(orderRoutingId) {
+        orderRoutings.value = JSON.parse(JSON.stringify(currentRoutingGroup.value["routings"]))
         initializeOrderRoutings();
       }
     }
@@ -264,16 +289,19 @@ function getArchivedOrderRoutings() {
 }
 
 async function updateGroupDescription() {
-  // Do not update description, if the desc is unchanged, we do not have routingGroupId, and description is leaft empty
+  // Do not update description, if the desc is unchanged, and we do not have routingGroupId, and description is left empty
   if(description.value && props.routingGroupId && currentRoutingGroup.value.description !== description.value) {
-    await store.dispatch("orderRouting/updateRoutingGroup", { routingGroupId: props.routingGroupId, fieldToUpdate: 'description', value: description.value })
+    const routingGroupId = await updateRoutingGroup({ routingGroupId: props.routingGroupId, productStoreId: currentEComStore.value.productStoreId, description: description.value })
+    if(routingGroupId) {
+      await store.dispatch("orderRouting/setCurrentGroup", { ...currentRoutingGroup.value, description: description.value })
+    }
   }
   isDescUpdating.value = false
 }
 
 function findRoutingsDiff(previousSeq: any, updatedSeq: any) {
   const diffSeq: any = Object.keys(previousSeq).reduce((diff, key) => {
-    if (updatedSeq[key].orderRoutingId === previousSeq[key].orderRoutingId) return diff
+    if (updatedSeq[key].orderRoutingId === previousSeq[key].orderRoutingId && updatedSeq[key].statusId === previousSeq[key].statusId && updatedSeq[key].sequenceNum === previousSeq[key].sequenceNum) return diff
     return {
       ...diff,
       [key]: updatedSeq[key]
@@ -283,22 +311,23 @@ function findRoutingsDiff(previousSeq: any, updatedSeq: any) {
 }
 
 function doReorder(event: CustomEvent) {
-  const previousSeq = JSON.parse(JSON.stringify(initialRoutingsOrder.value))
+  const previousSeq = JSON.parse(JSON.stringify(routingsForReorder.value))
 
   // returns the updated sequence after reordering
   const updatedSeq = event.detail.complete(JSON.parse(JSON.stringify(routingsForReorder.value)));
 
   let diffSeq = findRoutingsDiff(previousSeq, updatedSeq)
-
+  
   const updatedSeqenceNum = previousSeq.map((routing: Route) => routing.sequenceNum)
   Object.keys(diffSeq).map((key: any) => {
     diffSeq[key].sequenceNum = updatedSeqenceNum[key]
   })
 
   diffSeq = Object.keys(diffSeq).map((key) => diffSeq[key])
-
   routingsForReorder.value = updatedSeq
-  routingsToUpdate.value = diffSeq
+  orderRoutings.value = sortSequence(updatedSeq.concat(getArchivedOrderRoutings()))
+  // considering that when reordering there are some changes in the order of routes
+  hasUnsavedChanges.value = true
 }
 
 async function openArchivedRoutingModal() {
@@ -306,15 +335,89 @@ async function openArchivedRoutingModal() {
     component: ArchivedRoutingModal,
     componentProps: { archivedRoutings: getArchivedOrderRoutings() }
   })
+
+  archivedRoutingModal.onDidDismiss().then((result: any) => {
+    if(result.data?.routings?.length) {
+      hasUnsavedChanges.value = true
+      orderRoutings.value = sortSequence(getActiveAndDraftOrderRoutings().concat(result.data?.routings))
+    }
+    initializeOrderRoutings()
+  })
+
   archivedRoutingModal.present();
 }
 
 async function updateOrderRouting(routing: Route, fieldToUpdate: string, value: string) {
-  const orderRoutingId = await store.dispatch("orderRouting/updateOrderRouting", { orderRoutingId: routing.orderRoutingId, fieldToUpdate, value })
-  if(orderRoutingId) {
-    initializeOrderRoutings()
+  orderRoutings.value.map((route: any) => {
+    if(route.orderRoutingId === routing.orderRoutingId) {
+      route[fieldToUpdate] = value
+    }
+  })
+  hasUnsavedChanges.value = true
+  initializeOrderRoutings()
+}
+
+async function saveRoutingGroup() {
+  // Converting the routings into object { orderRoutingId: routing } format as to find the diff after performing all the operations
+  const initialRoutings = currentRoutingGroup.value["routings"].reduce((routings: any, routing: any) => {
+    routings[routing.orderRoutingId] = routing
+    return routings
+  }, {})
+
+  const finalRoutings = orderRoutings.value.reduce((routings: any, routing: any) => {
+    routings[routing.orderRoutingId] = routing
+    return routings
+  }, {})
+
+  const diff = findRoutingsDiff(initialRoutings, finalRoutings)
+
+  // If there is no diff in the routing order then do not make any api call and update hasUnsavedChanges values as we have made its value to true on calling of doReorder function
+  if(!Object.keys(diff).length) {
+    hasUnsavedChanges.value = false
+    return;
+  }
+
+  const routings = Object.values(diff).map((routing: any) => {
+    return {
+      routingGroupId: props.routingGroupId,
+      orderRoutingId: routing.orderRoutingId,
+      routingName: routing.routingName,
+      sequenceNum: routing.sequenceNum,
+      statusId: routing.statusId
+    }
+  })
+
+  const payload = {
+    routingGroupId: props.routingGroupId,
+    productStoreId: currentEComStore.value.productStoreId,
+    routings
+  }
+
+  const routingGroupId = await updateRoutingGroup(payload)
+  if(routingGroupId) {
+    hasUnsavedChanges.value = false
+    await store.dispatch("orderRouting/setCurrentGroup", { ...currentRoutingGroup.value, routings: orderRoutings.value })
   }
 }
+
+async function updateRoutingGroup(payload: any) {
+  let routingGroupId = ''
+  try {
+    const resp = await OrderRoutingService.updateRoutingGroup(payload);
+
+    if(!hasError(resp) && resp.data.routingGroupId) {
+      routingGroupId = resp.data.routingGroupId
+      showToast("Routing group information updated")
+    } else {
+      throw resp.data
+    }
+  } catch(err) {
+    showToast("Failed to update group information")
+    logger.error(err);
+  }
+
+  return routingGroupId
+}
 </script>
 
 <style scoped>
@@ -340,12 +443,6 @@ ion-content > div > div {
   border-right: 1px solid #92949C;
 }
 
-ion-modal.date-time-modal {
-  --width: 290px;
-  --height: 440px;
-  --border-radius: 8px;
-}
-
 .actions > ion-button {
   margin: var(--spacer-sm);
 }
diff --git a/src/views/BrokeringRuns.vue b/src/views/BrokeringRuns.vue
index 01bd683..4e961d2 100644
--- a/src/views/BrokeringRuns.vue
+++ b/src/views/BrokeringRuns.vue
@@ -87,7 +87,6 @@ async function addNewRun() {
 }
 
 async function redirect(group: Group) {
-  await store.dispatch('orderRouting/setCurrentRoutingGroup', group)
   router.push(`brokering/${group.routingGroupId}/routes`)
 }