diff --git a/apps/namada-interface/src/App/Token/TokenSend/TokenSendForm.tsx b/apps/namada-interface/src/App/Token/TokenSend/TokenSendForm.tsx
index 133c60d9c6f..e129b0cc044 100644
--- a/apps/namada-interface/src/App/Token/TokenSend/TokenSendForm.tsx
+++ b/apps/namada-interface/src/App/Token/TokenSend/TokenSendForm.tsx
@@ -9,6 +9,7 @@ import { AccountsState } from "slices/accounts";
 import {
   clearEvents,
   submitTransferTransaction,
+  actionTypes,
   TransfersState,
   TransferType,
 } from "slices/transfers";
@@ -36,6 +37,7 @@ import { Icon, IconName } from "components/Icon";
 import { useNavigate } from "react-router-dom";
 import { TopLevelRoute } from "App/types";
 import { ColorMode, DesignConfiguration } from "utils/theme";
+import { NotificationsState } from "slices/notifications";
 
 enum ComponentColor {
   GasButtonBorder,
@@ -156,8 +158,15 @@ const TokenSendForm = ({
   );
   const balancesForChain = balancesState[chainId] || {};
 
-  const { isTransferSubmitting, transferError, events } =
-    useAppSelector<TransfersState>((state) => state.transfers);
+  const isTransferSubmitting = useAppSelector<boolean>((state) =>
+    state.notifications.pendingActions.includes(
+      actionTypes.SUBMIT_TRANSFER_ACTION_TYPE
+    )
+  );
+
+  const { transferError } = useAppSelector<TransfersState>(
+    (state) => state.transfers
+  );
 
   const transparentAndShieldedAccounts = {
     ...derivedAccounts,
@@ -269,6 +278,7 @@ const TokenSendForm = ({
           amount,
           token: tokenType,
           feeAmount: gasFee,
+          notify: true
         })
       );
     }
@@ -423,15 +433,6 @@ const TokenSendForm = ({
 
       <StatusContainer>
         {transferError && <StatusMessage>{transferError}</StatusMessage>}
-        {isTransferSubmitting && (
-          <StatusMessage>Submitting transfer</StatusMessage>
-        )}
-        {events && (
-          <>
-            <StatusMessage>Transfer successful!</StatusMessage>
-            <StatusMessage>Gas used: {events.gas}</StatusMessage>
-          </>
-        )}
       </StatusContainer>
 
       <ButtonsContainer>
@@ -439,6 +440,7 @@ const TokenSendForm = ({
           <Icon iconName={IconName.ChevronLeft} />
         </BackButton>
         <Button
+          loading={isTransferSubmitting}
           variant={ButtonVariant.Contained}
           disabled={isFormInvalid}
           onClick={handleOnSendClick}
diff --git a/apps/namada-interface/src/slices/index.ts b/apps/namada-interface/src/slices/index.ts
index 12372c9d2fa..9769aabe50e 100644
--- a/apps/namada-interface/src/slices/index.ts
+++ b/apps/namada-interface/src/slices/index.ts
@@ -11,5 +11,5 @@ export { default as transfersReducer } from "./transfers";
 export { default as channelsReducer } from "./channels";
 export { default as settingsReducer } from "./settings";
 export { default as coinsReducer } from "./coins";
-export { default as notificationsReducer } from "./notifications";
+export { notificationsReducer } from "./notifications";
 export { stakingAndGovernanceReducers } from "./StakingAndGovernance";
diff --git a/apps/namada-interface/src/slices/notifications.ts b/apps/namada-interface/src/slices/notifications.ts
deleted file mode 100644
index d982cd96368..00000000000
--- a/apps/namada-interface/src/slices/notifications.ts
+++ /dev/null
@@ -1,58 +0,0 @@
-import { createSlice, PayloadAction } from "@reduxjs/toolkit";
-
-export type ToastType = "info" | "warning" | "error" | "success";
-
-export type ToastId = string;
-
-export type Toast = {
-  title: string;
-  message: string;
-  type: ToastType;
-  timeout: number;
-};
-
-export type NotificationsState = {
-  toasts: Record<ToastId, Toast>;
-};
-
-const initialState: NotificationsState = {
-  toasts: {},
-};
-
-const DEFAULT_TIMEOUT = 2000;
-
-const NOTIFICATIONS_ACTIONS_BASE = "notifications";
-
-export type CreateToastPayload = {
-  id: ToastId;
-  data: Omit<Toast, "timeout"> & Partial<Pick<Toast, "timeout">>;
-};
-
-export const NotificationsSlice = createSlice({
-  name: NOTIFICATIONS_ACTIONS_BASE,
-  initialState,
-  reducers: {
-    createToast: (state, action: PayloadAction<CreateToastPayload>) => {
-      const { id, data } = action.payload;
-      state.toasts = {
-        ...{
-          [id]: {
-            title: data.title,
-            message: data.message,
-            type: data.type,
-            timeout: data.timeout || DEFAULT_TIMEOUT,
-          },
-        },
-        ...state.toasts,
-      };
-    },
-    removeToast: (state, action: PayloadAction<{ id: ToastId }>) => {
-      const { [action.payload.id]: _, ...newToasts } = state.toasts;
-      state.toasts = newToasts;
-    },
-  },
-});
-
-export const actions = NotificationsSlice.actions;
-
-export default NotificationsSlice.reducer;
diff --git a/apps/namada-interface/src/slices/notifications/index.ts b/apps/namada-interface/src/slices/notifications/index.ts
new file mode 100644
index 00000000000..89b4e238f1c
--- /dev/null
+++ b/apps/namada-interface/src/slices/notifications/index.ts
@@ -0,0 +1,4 @@
+export { default as notificationsReducer } from "./slice";
+export { actions } from "./slice";
+export * from "./reducers";
+export * from "./types";
diff --git a/apps/namada-interface/src/slices/notifications/reducers.test.ts b/apps/namada-interface/src/slices/notifications/reducers.test.ts
new file mode 100644
index 00000000000..5b3fd2d2718
--- /dev/null
+++ b/apps/namada-interface/src/slices/notifications/reducers.test.ts
@@ -0,0 +1,302 @@
+import { NotificationsState, ToastType } from "./types";
+import reducer, { actions } from "./slice";
+import { DEFAULT_TIMEOUT, THUNK_MATCH_REGEXP } from "./reducers";
+import {
+  UnknownAsyncThunkFulfilledAction,
+  UnknownAsyncThunkPendingAction,
+  UnknownAsyncThunkRejectedAction,
+} from "@reduxjs/toolkit/dist/matchers";
+import { Action } from "@reduxjs/toolkit";
+
+describe("Notifications reducers", () => {
+  describe("createToast", () => {
+    it("should add new toast if toasts are empty", () => {
+      const state: NotificationsState = {
+        toasts: {},
+        pendingActions: ["action"],
+      };
+      const data = {
+        title: "A",
+        message: "B",
+        type: "info" as ToastType,
+        timeout: 2000,
+      };
+      const id = "some-id";
+      const createToastAction = actions.createToast({
+        id,
+        data,
+      });
+
+      expect(reducer(state, createToastAction)).toEqual({
+        toasts: { [id]: data },
+        pendingActions: ["action"],
+      });
+    });
+
+    it("should set default timeout if none is specified", () => {
+      const state: NotificationsState = {
+        toasts: {},
+        pendingActions: [],
+      };
+      const data = {
+        title: "A",
+        message: "B",
+        type: "info" as ToastType,
+      };
+      const id = "some-id";
+      const createToastAction = actions.createToast({
+        id,
+        data,
+      });
+
+      expect(reducer(state, createToastAction)).toEqual({
+        toasts: { [id]: { ...data, timeout: DEFAULT_TIMEOUT } },
+        pendingActions: [],
+      });
+    });
+
+    it("should add new toast if toasts are not empty", () => {
+      const initialToast = {
+        ["some-other-id"]: {
+          title: "A",
+          message: "B",
+          type: "error" as ToastType,
+          timeout: 1000,
+        },
+      };
+      const state: NotificationsState = {
+        toasts: { ...initialToast },
+        pendingActions: [],
+      };
+      const data = {
+        title: "A",
+        message: "B",
+        type: "info" as ToastType,
+        timeout: 2000,
+      };
+      const id = "some-id";
+      const createToastAction = actions.createToast({
+        id,
+        data,
+      });
+
+      expect(reducer(state, createToastAction)).toEqual({
+        toasts: { ...initialToast, [id]: data },
+        pendingActions: [],
+      });
+    });
+
+    it("should replace toast with the same id", () => {
+      const id = "some-id";
+      const initialToast = {
+        [id]: {
+          title: "A",
+          message: "B",
+          type: "error" as ToastType,
+          timeout: 1000,
+        },
+      };
+      const state: NotificationsState = {
+        toasts: { ...initialToast },
+        pendingActions: [],
+      };
+      const data = {
+        title: "A",
+        message: "B",
+        type: "info" as ToastType,
+        timeout: 2000,
+      };
+      const createToastAction = actions.createToast({
+        id,
+        data,
+      });
+
+      expect(reducer(state, createToastAction)).toEqual({
+        toasts: { [id]: data },
+        pendingActions: [],
+      });
+    });
+  });
+
+  describe("removeToast", () => {
+    it("should remove existing toast", () => {
+      const id = "some-id";
+      const initialToast = {
+        [id]: {
+          title: "A",
+          message: "B",
+          type: "error" as ToastType,
+          timeout: 1000,
+        },
+      };
+      const state: NotificationsState = {
+        toasts: { ...initialToast },
+        pendingActions: [],
+      };
+
+      const removeToastAction = actions.removeToast({
+        id,
+      });
+
+      expect(reducer(state, removeToastAction)).toEqual({
+        toasts: {},
+        pendingActions: [],
+      });
+    });
+
+    it("should do nothing when toast with given id is not present", () => {
+      const id = "some-id";
+      const initialToast = {
+        [id]: {
+          title: "A",
+          message: "B",
+          type: "error" as ToastType,
+          timeout: 1000,
+        },
+      };
+      const state: NotificationsState = {
+        toasts: { ...initialToast },
+        pendingActions: [],
+      };
+
+      const removeToastAction = actions.removeToast({
+        id: "different-id",
+      });
+
+      expect(reducer(state, removeToastAction)).toEqual(state);
+    });
+  });
+
+  describe("setPendingAction", () => {
+    it("should add pending action if not present", () => {
+      const state: NotificationsState = {
+        toasts: {},
+        pendingActions: [],
+      };
+      const pendingAction = {
+        type: "A/name/pending",
+        meta: {
+          requestId: "A",
+          requestStatus: "pending",
+        },
+      } as UnknownAsyncThunkPendingAction;
+
+      expect(reducer(state, pendingAction)).toEqual({
+        toasts: {},
+        pendingActions: ["A/name"],
+      });
+    });
+
+    it("should not add pending action if present", () => {
+      const action = "A/name";
+      const state: NotificationsState = {
+        toasts: {},
+        pendingActions: [action],
+      };
+      const pendingAction = {
+        type: `${action}/pending`,
+        meta: {
+          requestId: "A",
+          requestStatus: "pending",
+        },
+      } as UnknownAsyncThunkPendingAction;
+
+      expect(reducer(state, pendingAction)).toEqual({
+        toasts: {},
+        pendingActions: ["A/name"],
+      });
+    });
+
+    it("should clear pending action if it is fulfilled", () => {
+      const actionType = "A/name";
+      const state: NotificationsState = {
+        toasts: {},
+        pendingActions: [actionType],
+      };
+      const pendingAction = {
+        type: `${actionType}/fulfilled`,
+        meta: {
+          requestId: "A",
+          requestStatus: "fulfilled",
+        },
+      } as UnknownAsyncThunkFulfilledAction;
+
+      expect(reducer(state, pendingAction)).toEqual({
+        toasts: {},
+        pendingActions: [],
+      });
+    });
+
+    it("should clear pending action if it is rejected", () => {
+      const actionType = "A/name";
+      const state: NotificationsState = {
+        toasts: {},
+        pendingActions: [actionType],
+      };
+      const pendingAction = {
+        type: `${actionType}/rejected`,
+        meta: {
+          requestId: "A",
+          requestStatus: "rejected",
+        },
+      } as UnknownAsyncThunkRejectedAction;
+
+      expect(reducer(state, pendingAction)).toEqual({
+        toasts: {},
+        pendingActions: [],
+      });
+    });
+
+    it("should do nothing if actionType is not matched", () => {
+      const actionType = "A/name";
+      const state: NotificationsState = {
+        toasts: {},
+        pendingActions: [actionType],
+      };
+      const pendingAction = {
+        type: "some action",
+      } as Action;
+
+      expect(reducer(state, pendingAction)).toEqual({
+        toasts: {},
+        pendingActions: ["A/name"],
+      });
+    });
+  });
+});
+
+describe("Thunk match regexp", () => {
+  it("should not match empty string", () => {
+    expect("".match(THUNK_MATCH_REGEXP)).toBeNull();
+  });
+
+  it("should not match a string without a slash('/')", () => {
+    expect("hello".match(THUNK_MATCH_REGEXP)).toBeNull();
+  });
+
+  it("should not match a string with a slash('/') and arbitrary chars after", () => {
+    expect("hello/world".match(THUNK_MATCH_REGEXP)).toBeNull();
+  });
+
+  it("should not match a string with multiple slashes('/') and arbitrary chars after", () => {
+    expect("hello/world/!!!".match(THUNK_MATCH_REGEXP)).toBeNull();
+  });
+
+  it("should match a string with a slash('/') followed by pending/fulfilled/rejected", () => {
+    expect("hello/pending".match(THUNK_MATCH_REGEXP)![0]).toEqual("hello");
+    expect("hello/fulfilled".match(THUNK_MATCH_REGEXP)![0]).toEqual("hello");
+    expect("hello/rejected".match(THUNK_MATCH_REGEXP)![0]).toEqual("hello");
+  });
+
+  it("should match a string with multiple slashes('/') followed by pending/fulfilled/rejected", () => {
+    expect("hello/world/pending".match(THUNK_MATCH_REGEXP)![0]).toEqual(
+      "hello/world"
+    );
+    expect(
+      "hello/world/action/fulfilled".match(THUNK_MATCH_REGEXP)![0]
+    ).toEqual("hello/world/action");
+    expect(
+      "hello/world/action/more-action/rejected".match(THUNK_MATCH_REGEXP)![0]
+    ).toEqual("hello/world/action/more-action");
+  });
+});
diff --git a/apps/namada-interface/src/slices/notifications/reducers.ts b/apps/namada-interface/src/slices/notifications/reducers.ts
new file mode 100644
index 00000000000..370444408af
--- /dev/null
+++ b/apps/namada-interface/src/slices/notifications/reducers.ts
@@ -0,0 +1,61 @@
+import {
+  PayloadAction,
+  isPending,
+  isFulfilled,
+  isRejected,
+  Action,
+  isAsyncThunkAction,
+  ActionReducerMapBuilder,
+} from "@reduxjs/toolkit";
+
+import { CreateToastPayload, ToastId, NotificationsState } from "./types";
+
+export const DEFAULT_TIMEOUT = 2000;
+export const THUNK_MATCH_REGEXP = /^.*(?=\/(pending|fulfilled|rejected)$)/;
+
+export const reducers = {
+  createToast: (
+    state: NotificationsState,
+    action: PayloadAction<CreateToastPayload>
+  ) => {
+    const { id, data } = action.payload;
+    state.toasts = {
+      ...state.toasts,
+      [id]: {
+        title: data.title,
+        message: data.message,
+        type: data.type,
+        timeout: data.timeout || DEFAULT_TIMEOUT,
+      },
+    };
+  },
+  removeToast: (
+    state: NotificationsState,
+    action: PayloadAction<{ id: ToastId }>
+  ) => {
+    const { [action.payload.id]: _, ...newToasts } = state.toasts;
+    state.toasts = newToasts;
+  },
+};
+
+export const extraReducers = (
+  builder: ActionReducerMapBuilder<NotificationsState>
+): void => {
+  builder.addMatcher(
+    isAsyncThunkAction,
+    (state: NotificationsState, action: Action) => {
+      const [actionType] =
+        action.type.match(THUNK_MATCH_REGEXP) || [];
+      const pendingSet = new Set(state.pendingActions);
+
+      if (actionType) {
+        if (isPending(action)) {
+          pendingSet.add(actionType);
+        } else if (isFulfilled(action) || isRejected(action)) {
+          pendingSet.delete(actionType);
+        }
+        state.pendingActions = Array.from(pendingSet);
+      }
+    }
+  );
+};
diff --git a/apps/namada-interface/src/slices/notifications/slice.ts b/apps/namada-interface/src/slices/notifications/slice.ts
new file mode 100644
index 00000000000..22349261ae2
--- /dev/null
+++ b/apps/namada-interface/src/slices/notifications/slice.ts
@@ -0,0 +1,22 @@
+import { createSlice } from "@reduxjs/toolkit";
+
+import { NotificationsState } from "./types";
+import { reducers, extraReducers } from "./reducers";
+
+const initialState: NotificationsState = {
+  toasts: {},
+  pendingActions: [],
+};
+
+const NOTIFICATIONS_ACTIONS_BASE = "notifications";
+
+export const NotificationsSlice = createSlice({
+  name: NOTIFICATIONS_ACTIONS_BASE,
+  initialState,
+  reducers,
+  extraReducers
+});
+
+export const actions = NotificationsSlice.actions;
+
+export default NotificationsSlice.reducer;
diff --git a/apps/namada-interface/src/slices/notifications/types.ts b/apps/namada-interface/src/slices/notifications/types.ts
new file mode 100644
index 00000000000..b87af0620ed
--- /dev/null
+++ b/apps/namada-interface/src/slices/notifications/types.ts
@@ -0,0 +1,20 @@
+export type ToastType = "info" | "warning" | "error" | "success";
+
+export type ToastId = string;
+
+export type Toast = {
+  title: string;
+  message: string;
+  type: ToastType;
+  timeout: number;
+};
+
+export type NotificationsState = {
+  toasts: Record<ToastId, Toast>;
+  pendingActions: string[];
+};
+
+export type CreateToastPayload = {
+  id: ToastId;
+  data: Omit<Toast, "timeout"> & Partial<Pick<Toast, "timeout">>;
+};
diff --git a/apps/namada-interface/src/slices/transfers.ts b/apps/namada-interface/src/slices/transfers.ts
index f508b10735f..b9b08dfd0af 100644
--- a/apps/namada-interface/src/slices/transfers.ts
+++ b/apps/namada-interface/src/slices/transfers.ts
@@ -29,6 +29,46 @@ import {
   TRANSFER_CONFIGURATION,
 } from "./shieldedTransfer";
 import { updateShieldedBalances } from "./AccountsNew";
+import {
+  actions as notificationsActions,
+  CreateToastPayload,
+  ToastId,
+  ToastType,
+} from "slices/notifications";
+
+enum Toasts {
+  TransferStarted,
+  TransferCompleted,
+}
+
+type TransferCompletedToastProps = { gas: number };
+type GetToastProps = TransferCompletedToastProps | void;
+
+const getToast = (
+  toastId: ToastId,
+  toast: Toasts
+): ((props: GetToastProps) => CreateToastPayload) => {
+  const toasts = {
+    [Toasts.TransferStarted]: () => ({
+      id: toastId,
+      data: {
+        title: "Transfer started!",
+        message: "",
+        type: "info" as ToastType,
+      },
+    }),
+    [Toasts.TransferCompleted]: ({ gas }: TransferCompletedToastProps) => ({
+      id: toastId,
+      data: {
+        title: "Transfer successful!",
+        message: `Gas used: ${gas}`,
+        type: "success" as ToastType,
+      },
+    }),
+  };
+
+  return toasts[toast] as (props: GetToastProps) => CreateToastPayload;
+};
 
 const TRANSFERS_ACTIONS_BASE = "transfers";
 const LEDGER_TRANSFER_TIMEOUT = 20000;
@@ -84,6 +124,8 @@ enum TransfersThunkActions {
   SubmitIbcTransferTransaction = "submitIbcTransferTransaction",
 }
 
+type WithNotification<T> = T & { notify?: boolean };
+
 type TxArgs = {
   chainId: string;
   account: DerivedAccount | ShieldedAccount;
@@ -221,16 +263,19 @@ const createTransfer = async (
   }
 };
 
+export const actionTypes = {
+  SUBMIT_TRANSFER_ACTION_TYPE: `${TRANSFERS_ACTIONS_BASE}/${TransfersThunkActions.SubmitTransferTransaction}`,
+};
 // this takes care of 4 different variations of transfers:
 // shielded -> shielded
 // transparent -> shielded
 // shielded -> transparent
 // transparent -> transparente
 export const submitTransferTransaction = createAsyncThunk(
-  `${TRANSFERS_ACTIONS_BASE}/${TransfersThunkActions.SubmitTransferTransaction}`,
+  actionTypes.SUBMIT_TRANSFER_ACTION_TYPE,
   async (
-    txTransferArgs: TxTransferArgs | ShieldedTransferData,
-    { dispatch, rejectWithValue }
+    txTransferArgs: WithNotification<TxTransferArgs | ShieldedTransferData>,
+    { dispatch, rejectWithValue, requestId }
   ) => {
     const {
       account,
@@ -240,6 +285,7 @@ export const submitTransferTransaction = createAsyncThunk(
       memo = "",
       faucet,
       chainId,
+      notify,
     } = txTransferArgs;
     const { id, establishedAddress = "", signingKey: privateKey } = account;
 
@@ -255,6 +301,13 @@ export const submitTransferTransaction = createAsyncThunk(
       protocol: network.wsProtocol,
     });
 
+    notify &&
+      dispatch(
+        notificationsActions.createToast(
+          getToast(`${requestId}-pending`, Toasts.TransferStarted)()
+        )
+      );
+
     let epoch: number;
     try {
       epoch = await rpcClient.queryEpoch();
@@ -320,6 +373,15 @@ export const submitTransferTransaction = createAsyncThunk(
     //     txTransferArgs.account.id
     //   )
     // );
+    //
+    notify && dispatch(
+      notificationsActions.createToast(
+        getToast(
+          `${requestId}-fullfilled`,
+          Toasts.TransferCompleted
+        )({ gas: gas })
+      )
+    );
 
     return {
       id,
diff --git a/apps/namada-interface/src/store/mocks.ts b/apps/namada-interface/src/store/mocks.ts
index 80973be7c67..512df7b6ef0 100644
--- a/apps/namada-interface/src/store/mocks.ts
+++ b/apps/namada-interface/src/store/mocks.ts
@@ -225,6 +225,7 @@ export const mockAppState: RootState = {
     myStakingPositions: [],
   },
   notifications: {
-    toasts: {} 
-  }
+    toasts: {},
+    pendingActions: [],
+  },
 };