diff --git a/package-lock.json b/package-lock.json
index dc107cb24..27ff6799e 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -21,8 +21,7 @@
         "@fortawesome/react-fontawesome": "^0.2.0",
         "@openedx/frontend-plugin-framework": "^1.7.0",
         "@openedx/paragon": "^23.4.5",
-        "@redux-devtools/extension": "3.3.0",
-        "@reduxjs/toolkit": "^2.0.0",
+        "@tanstack/react-query": "^5.90.16",
         "classnames": "^2.3.1",
         "core-js": "3.47.0",
         "font-awesome": "4.7.0",
@@ -34,14 +33,9 @@
         "react-dom": "^18.3.1",
         "react-helmet": "^6.1.0",
         "react-intl": "6.8.9",
-        "react-redux": "^7.2.4",
         "react-router-dom": "6.30.3",
         "react-share": "^4.4.0",
-        "redux": "4.2.1",
-        "redux-logger": "3.0.6",
-        "redux-thunk": "2.4.2",
         "regenerator-runtime": "^0.14.0",
-        "reselect": "^4.0.0",
         "universal-cookie": "^4.0.4",
         "util": "^0.12.4"
       },
@@ -59,8 +53,7 @@
         "jest-expect-message": "^1.1.3",
         "jest-when": "^3.6.0",
         "react-dev-utils": "^12.0.0",
-        "react-test-renderer": "^18.3.1",
-        "redux-mock-store": "^1.5.4"
+        "react-test-renderer": "^18.3.1"
       }
     },
     "node_modules/@adobe/css-tools": {
@@ -2590,14 +2583,14 @@
       }
     },
     "node_modules/@emnapi/core": {
-      "version": "1.4.3",
-      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.4.3.tgz",
-      "integrity": "sha512-4m62DuCE07lw01soJwPiBGC0nAww0Q+RY70VZ+n49yDIO13yyinhbWCeNnaob0lakDtWQzSdtNWzJeOJt2ma+g==",
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.8.1.tgz",
+      "integrity": "sha512-AvT9QFpxK0Zd8J0jopedNm+w/2fIzvtPKPjqyw9jwvBaReTTqPBk9Hixaz7KbjimP+QNz605/XnjFcDAL2pqBg==",
       "dev": true,
       "license": "MIT",
       "optional": true,
       "dependencies": {
-        "@emnapi/wasi-threads": "1.0.2",
+        "@emnapi/wasi-threads": "1.1.0",
         "tslib": "^2.4.0"
       }
     },
@@ -2613,9 +2606,9 @@
       }
     },
     "node_modules/@emnapi/wasi-threads": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.0.2.tgz",
-      "integrity": "sha512-5n3nTJblwRi8LlXkJ9eBzu+kZR8Yxcc7ubakyQTFzPMtIhFpUBRbsnc2Dv88IZDIbCDlBiWrknhB4Lsz7mg6BA==",
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.1.0.tgz",
+      "integrity": "sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==",
       "dev": true,
       "license": "MIT",
       "optional": true,
@@ -4365,16 +4358,16 @@
       "license": "MIT"
     },
     "node_modules/@napi-rs/wasm-runtime": {
-      "version": "0.2.11",
-      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-0.2.11.tgz",
-      "integrity": "sha512-9DPkXtvHydrcOsopiYpUgPHpmj0HWZKMUnL2dZqpvC42lsratuBG06V5ipyno0fUek5VlFsNQ+AcFATSrJXgMA==",
+      "version": "0.2.12",
+      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-0.2.12.tgz",
+      "integrity": "sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==",
       "dev": true,
       "license": "MIT",
       "optional": true,
       "dependencies": {
         "@emnapi/core": "^1.4.3",
         "@emnapi/runtime": "^1.4.3",
-        "@tybys/wasm-util": "^0.9.0"
+        "@tybys/wasm-util": "^0.10.0"
       }
     },
     "node_modules/@newrelic/publish-sourcemap": {
@@ -5318,67 +5311,6 @@
         "url": "https://opencollective.com/popperjs"
       }
     },
-    "node_modules/@redux-devtools/extension": {
-      "version": "3.3.0",
-      "resolved": "https://registry.npmjs.org/@redux-devtools/extension/-/extension-3.3.0.tgz",
-      "integrity": "sha512-X34S/rC8S/M1BIrkYD1mJ5f8vlH0BDqxXrs96cvxSBo4FhMdbhU+GUGsmNYov1xjSyLMHgo8NYrUG8bNX7525g==",
-      "license": "MIT",
-      "dependencies": {
-        "@babel/runtime": "^7.23.2",
-        "immutable": "^4.3.4"
-      },
-      "peerDependencies": {
-        "redux": "^3.1.0 || ^4.0.0 || ^5.0.0"
-      }
-    },
-    "node_modules/@reduxjs/toolkit": {
-      "version": "2.11.2",
-      "resolved": "https://registry.npmjs.org/@reduxjs/toolkit/-/toolkit-2.11.2.tgz",
-      "integrity": "sha512-Kd6kAHTA6/nUpp8mySPqj3en3dm0tdMIgbttnQ1xFMVpufoj+ADi8pXLBsd4xzTRHQa7t/Jv8W5UnCuW4kuWMQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@standard-schema/spec": "^1.0.0",
-        "@standard-schema/utils": "^0.3.0",
-        "immer": "^11.0.0",
-        "redux": "^5.0.1",
-        "redux-thunk": "^3.1.0",
-        "reselect": "^5.1.0"
-      },
-      "peerDependencies": {
-        "react": "^16.9.0 || ^17.0.0 || ^18 || ^19",
-        "react-redux": "^7.2.1 || ^8.1.3 || ^9.0.0"
-      },
-      "peerDependenciesMeta": {
-        "react": {
-          "optional": true
-        },
-        "react-redux": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@reduxjs/toolkit/node_modules/redux": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/redux/-/redux-5.0.1.tgz",
-      "integrity": "sha512-M9/ELqF6fy8FwmkpnF0S3YKOqMyoWJ4+CS5Efg2ct3oY9daQvd/Pc71FpGZsVsbl3Cpb+IIcjBDUnnyBdQbq4w==",
-      "license": "MIT",
-      "peer": true
-    },
-    "node_modules/@reduxjs/toolkit/node_modules/redux-thunk": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/redux-thunk/-/redux-thunk-3.1.0.tgz",
-      "integrity": "sha512-NW2r5T6ksUKXCabzhL9z+h206HQw/NJkcLm1GPImRQ8IzfXwRGqjVhKJGauHirT0DAuyy6hjdnMZaRoAcy0Klw==",
-      "license": "MIT",
-      "peerDependencies": {
-        "redux": "^5.0.0"
-      }
-    },
-    "node_modules/@reduxjs/toolkit/node_modules/reselect": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/reselect/-/reselect-5.1.1.tgz",
-      "integrity": "sha512-K/BG6eIky/SBpzfHZv/dd+9JBFiS4SWV7FIujVyJRux6e45+73RaUHXLmIR1f7WOMaQ0U1km6qwklRQxpJJY0w==",
-      "license": "MIT"
-    },
     "node_modules/@remix-run/router": {
       "version": "1.23.2",
       "resolved": "https://registry.npmjs.org/@remix-run/router/-/router-1.23.2.tgz",
@@ -5440,18 +5372,6 @@
         "@sinonjs/commons": "^3.0.0"
       }
     },
-    "node_modules/@standard-schema/spec": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.0.0.tgz",
-      "integrity": "sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA==",
-      "license": "MIT"
-    },
-    "node_modules/@standard-schema/utils": {
-      "version": "0.3.0",
-      "resolved": "https://registry.npmjs.org/@standard-schema/utils/-/utils-0.3.0.tgz",
-      "integrity": "sha512-e7Mew686owMaPJVNNLs55PUvgz371nKgwsc4vxE49zsODpJEnxgxRo2y/OKrqueavXgZNMDVj3DdHFlaSAeU8g==",
-      "license": "MIT"
-    },
     "node_modules/@svgr/babel-plugin-add-jsx-attribute": {
       "version": "8.0.0",
       "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-8.0.0.tgz",
@@ -5724,6 +5644,32 @@
         "url": "https://github.com/sponsors/gregberge"
       }
     },
+    "node_modules/@tanstack/query-core": {
+      "version": "5.90.16",
+      "resolved": "https://registry.npmjs.org/@tanstack/query-core/-/query-core-5.90.16.tgz",
+      "integrity": "sha512-MvtWckSVufs/ja463/K4PyJeqT+HMlJWtw6PrCpywznd2NSgO3m4KwO9RqbFqGg6iDE8vVMFWMeQI4Io3eEYww==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/tannerlinsley"
+      }
+    },
+    "node_modules/@tanstack/react-query": {
+      "version": "5.90.16",
+      "resolved": "https://registry.npmjs.org/@tanstack/react-query/-/react-query-5.90.16.tgz",
+      "integrity": "sha512-bpMGOmV4OPmif7TNMteU/Ehf/hoC0Kf98PDc0F4BZkFrEapRMEqI/V6YS0lyzwSV6PQpY1y4xxArUIfBW5LVxQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@tanstack/query-core": "5.90.16"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/tannerlinsley"
+      },
+      "peerDependencies": {
+        "react": "^18 || ^19"
+      }
+    },
     "node_modules/@testing-library/dom": {
       "version": "10.4.0",
       "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.0.tgz",
@@ -5860,9 +5806,9 @@
       }
     },
     "node_modules/@tybys/wasm-util": {
-      "version": "0.9.0",
-      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.9.0.tgz",
-      "integrity": "sha512-6+7nlbMVX/PVDCwaIQ8nTOPveOcFLSt8GcXdx8hD0bt39uWxYT88uXzqTd4fTvqta7oeUJqudepapKNt2DYJFw==",
+      "version": "0.10.1",
+      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.1.tgz",
+      "integrity": "sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==",
       "dev": true,
       "license": "MIT",
       "optional": true,
@@ -9595,12 +9541,6 @@
         }
       }
     },
-    "node_modules/deep-diff": {
-      "version": "0.3.8",
-      "resolved": "https://registry.npmjs.org/deep-diff/-/deep-diff-0.3.8.tgz",
-      "integrity": "sha512-yVn6RZmHiGnxRKR9sJb3iVV2XTF1Ghh2DiWRZ3dMnGc43yUdWWF/kX6lQyk3+P84iprfWKU/8zFTrlkvtFm1ug==",
-      "license": "MIT"
-    },
     "node_modules/deep-is": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
@@ -13210,22 +13150,6 @@
       "integrity": "sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==",
       "license": "MIT"
     },
-    "node_modules/immer": {
-      "version": "11.0.0",
-      "resolved": "https://registry.npmjs.org/immer/-/immer-11.0.0.tgz",
-      "integrity": "sha512-XtRG4SINt4dpqlnJvs70O2j6hH7H0X8fUzFsjMn1rwnETaxwp83HLNimXBjZ78MrKl3/d3/pkzDH0o0Lkxm37Q==",
-      "license": "MIT",
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/immer"
-      }
-    },
-    "node_modules/immutable": {
-      "version": "4.3.7",
-      "resolved": "https://registry.npmjs.org/immutable/-/immutable-4.3.7.tgz",
-      "integrity": "sha512-1hqclzwYwjRDFLjcFxOM5AYkkG0rpFPpr1RLPMEuGczoS7YA8gLhy8SWXYRAA/XwfEHpfo3cw5JGioS32fnMRw==",
-      "license": "MIT"
-    },
     "node_modules/import-fresh": {
       "version": "3.3.1",
       "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
@@ -15660,13 +15584,6 @@
       "devOptional": true,
       "license": "MIT"
     },
-    "node_modules/lodash.isplainobject": {
-      "version": "4.0.6",
-      "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz",
-      "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/lodash.memoize": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz",
@@ -19104,37 +19021,6 @@
         "@babel/runtime": "^7.9.2"
       }
     },
-    "node_modules/redux-logger": {
-      "version": "3.0.6",
-      "resolved": "https://registry.npmjs.org/redux-logger/-/redux-logger-3.0.6.tgz",
-      "integrity": "sha512-JoCIok7bg/XpqA1JqCqXFypuqBbQzGQySrhFzewB7ThcnysTO30l4VCst86AuB9T9tuT03MAA56Jw2PNhRSNCg==",
-      "license": "MIT",
-      "dependencies": {
-        "deep-diff": "^0.3.5"
-      }
-    },
-    "node_modules/redux-mock-store": {
-      "version": "1.5.5",
-      "resolved": "https://registry.npmjs.org/redux-mock-store/-/redux-mock-store-1.5.5.tgz",
-      "integrity": "sha512-YxX+ofKUTQkZE4HbhYG4kKGr7oCTJfB0GLy7bSeqx86GLpGirrbUWstMnqXkqHNaQpcnbMGbof2dYs5KsPE6Zg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "lodash.isplainobject": "^4.0.6"
-      },
-      "peerDependencies": {
-        "redux": "*"
-      }
-    },
-    "node_modules/redux-thunk": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/redux-thunk/-/redux-thunk-2.4.2.tgz",
-      "integrity": "sha512-+P3TjtnP0k/FEjcBL5FZpoovtvrTNT/UXd4/sluaSyrURlSlhLSzEdfsTBW7WsKB6yPvgd7q/iZPICFjW4o57Q==",
-      "license": "MIT",
-      "peerDependencies": {
-        "redux": "^4"
-      }
-    },
     "node_modules/reflect.getprototypeof": {
       "version": "1.0.10",
       "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
@@ -19312,12 +19198,6 @@
       "integrity": "sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==",
       "license": "MIT"
     },
-    "node_modules/reselect": {
-      "version": "4.1.8",
-      "resolved": "https://registry.npmjs.org/reselect/-/reselect-4.1.8.tgz",
-      "integrity": "sha512-ab9EmR80F/zQTMNeneUr4cv+jSwPJgIlvEmVwLerwrWVbpLlBuls9XHzIeTFy4cegU2NHBp3va0LKOzU5qFEYQ==",
-      "license": "MIT"
-    },
     "node_modules/resolve": {
       "version": "1.22.10",
       "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz",
diff --git a/package.json b/package.json
index 321c05b76..6fd187c97 100755
--- a/package.json
+++ b/package.json
@@ -41,8 +41,7 @@
     "@fortawesome/react-fontawesome": "^0.2.0",
     "@openedx/frontend-plugin-framework": "^1.7.0",
     "@openedx/paragon": "^23.4.5",
-    "@redux-devtools/extension": "3.3.0",
-    "@reduxjs/toolkit": "^2.0.0",
+    "@tanstack/react-query": "^5.90.16",
     "classnames": "^2.3.1",
     "core-js": "3.47.0",
     "font-awesome": "4.7.0",
@@ -54,14 +53,9 @@
     "react-dom": "^18.3.1",
     "react-helmet": "^6.1.0",
     "react-intl": "6.8.9",
-    "react-redux": "^7.2.4",
     "react-router-dom": "6.30.3",
     "react-share": "^4.4.0",
-    "redux": "4.2.1",
-    "redux-logger": "3.0.6",
-    "redux-thunk": "2.4.2",
     "regenerator-runtime": "^0.14.0",
-    "reselect": "^4.0.0",
     "universal-cookie": "^4.0.4",
     "util": "^0.12.4"
   },
@@ -79,7 +73,6 @@
     "jest-expect-message": "^1.1.3",
     "jest-when": "^3.6.0",
     "react-dev-utils": "^12.0.0",
-    "react-test-renderer": "^18.3.1",
-    "redux-mock-store": "^1.5.4"
+    "react-test-renderer": "^18.3.1"
   }
 }
diff --git a/src/App.jsx b/src/App.jsx
index 2c148f98e..c8d914f9c 100755
--- a/src/App.jsx
+++ b/src/App.jsx
@@ -5,60 +5,30 @@ import { useIntl } from '@edx/frontend-platform/i18n';
 import { logError } from '@edx/frontend-platform/logging';
 import { initializeHotjar } from '@edx/frontend-enterprise-hotjar';
 
-import { ErrorPage, AppContext } from '@edx/frontend-platform/react';
+import { ErrorPage } from '@edx/frontend-platform/react';
 import { FooterSlot } from '@edx/frontend-component-footer';
 import { Alert } from '@openedx/paragon';
 
-import { RequestKeys } from 'data/constants/requests';
-import store from 'data/store';
-import {
-  selectors,
-  actions,
-} from 'data/redux';
-import { reduxHooks } from 'hooks';
 import Dashboard from 'containers/Dashboard';
 
-import track from 'tracking';
-
-import fakeData from 'data/services/lms/fakeData/courses';
-
 import AppWrapper from 'containers/AppWrapper';
 import LearnerDashboardHeader from 'containers/LearnerDashboardHeader';
 
 import { getConfig } from '@edx/frontend-platform';
+import { useInitializeLearnerHome } from 'data/hooks';
+import { useMasquerade } from 'data/context';
 import messages from './messages';
 import './App.scss';
 
 export const App = () => {
-  const { authenticatedUser } = React.useContext(AppContext);
   const { formatMessage } = useIntl();
-  const isFailed = {
-    initialize: reduxHooks.useRequestIsFailed(RequestKeys.initialize),
-    refreshList: reduxHooks.useRequestIsFailed(RequestKeys.refreshList),
-  };
-  const hasNetworkFailure = isFailed.initialize || isFailed.refreshList;
-  const { supportEmail } = reduxHooks.usePlatformSettingsData();
-  const loadData = reduxHooks.useLoadData();
+  const { masqueradeUser } = useMasquerade();
+  const { data, isError } = useInitializeLearnerHome();
+  const hasNetworkFailure = !masqueradeUser && isError;
+  const supportEmail = data?.platformSettings?.supportEmail || undefined;
 
+  /* istanbul ignore next */
   React.useEffect(() => {
-    if (authenticatedUser?.administrator || getConfig().NODE_ENV === 'development') {
-      window.loadEmptyData = () => {
-        loadData({ ...fakeData.globalData, courses: [] });
-      };
-      window.loadMockData = () => {
-        loadData({
-          ...fakeData.globalData,
-          courses: [
-            ...fakeData.courseRunData,
-            ...fakeData.entitlementData,
-          ],
-        });
-      };
-      window.store = store;
-      window.selectors = selectors;
-      window.actions = actions;
-      window.track = track;
-    }
     if (getConfig().HOTJAR_APP_ID) {
       try {
         initializeHotjar({
@@ -70,7 +40,7 @@ export const App = () => {
         logError(error);
       }
     }
-  }, [authenticatedUser, loadData]);
+  }, []);
   return (
     <>
       <Helmet>
diff --git a/src/App.test.jsx b/src/App.test.jsx
index 102d3792d..149419545 100644
--- a/src/App.test.jsx
+++ b/src/App.test.jsx
@@ -3,30 +3,24 @@ import { render, screen, waitFor } from '@testing-library/react';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 import { getConfig } from '@edx/frontend-platform';
 
-import { RequestKeys } from 'data/constants/requests';
-import { reduxHooks } from 'hooks';
+import { useInitializeLearnerHome } from 'data/hooks';
 import { App } from './App';
 import messages from './messages';
 
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn(),
+}));
+
+jest.mock('data/context/MasqueradeProvider', () => ({
+  useMasquerade: jest.fn(() => ({ masqueradeUser: null })),
+}));
+
 jest.mock('@edx/frontend-component-footer', () => ({
   FooterSlot: jest.fn(() => <div>FooterSlot</div>),
 }));
 jest.mock('containers/Dashboard', () => jest.fn(() => <div>Dashboard</div>));
 jest.mock('containers/LearnerDashboardHeader', () => jest.fn(() => <div>LearnerDashboardHeader</div>));
 jest.mock('containers/AppWrapper', () => jest.fn(({ children }) => <div className="AppWrapper">{children}</div>));
-jest.mock('data/redux', () => ({
-  selectors: 'redux.selectors',
-  actions: 'redux.actions',
-  thunkActions: 'redux.thunkActions',
-}));
-jest.mock('hooks', () => ({
-  reduxHooks: {
-    useRequestIsFailed: jest.fn(),
-    usePlatformSettingsData: jest.fn(),
-    useLoadData: jest.fn(),
-  },
-}));
-jest.mock('data/store', () => 'data/store');
 
 jest.mock('@edx/frontend-platform', () => ({
   getConfig: jest.fn(() => ({})),
@@ -37,11 +31,15 @@ jest.mock('@edx/frontend-platform/react', () => ({
   ErrorPage: () => 'ErrorPage',
 }));
 
-const loadData = jest.fn();
-reduxHooks.useLoadData.mockReturnValue(loadData);
-
 const supportEmail = 'test@support.com';
-reduxHooks.usePlatformSettingsData.mockReturnValue({ supportEmail });
+useInitializeLearnerHome.mockReturnValue({
+  data: {
+    platformSettings: {
+      supportEmail,
+    },
+  },
+  isError: false,
+});
 
 describe('App router component', () => {
   describe('component', () => {
@@ -66,7 +64,6 @@ describe('App router component', () => {
     describe('no network failure', () => {
       beforeEach(() => {
         jest.clearAllMocks();
-        reduxHooks.useRequestIsFailed.mockReturnValue(false);
         getConfig.mockReturnValue({});
         render(<IntlProvider locale="en"><App /></IntlProvider>);
       });
@@ -79,7 +76,6 @@ describe('App router component', () => {
     describe('no network failure with optimizely url', () => {
       beforeEach(() => {
         jest.clearAllMocks();
-        reduxHooks.useRequestIsFailed.mockReturnValue(false);
         getConfig.mockReturnValue({ OPTIMIZELY_URL: 'fake.url' });
         render(<IntlProvider locale="en"><App /></IntlProvider>);
       });
@@ -92,7 +88,6 @@ describe('App router component', () => {
     describe('no network failure with optimizely project id', () => {
       beforeEach(() => {
         jest.clearAllMocks();
-        reduxHooks.useRequestIsFailed.mockReturnValue(false);
         getConfig.mockReturnValue({ OPTIMIZELY_PROJECT_ID: 'fakeId' });
         render(<IntlProvider locale="en"><App /></IntlProvider>);
       });
@@ -105,7 +100,10 @@ describe('App router component', () => {
     describe('initialize failure', () => {
       beforeEach(() => {
         jest.clearAllMocks();
-        reduxHooks.useRequestIsFailed.mockImplementation((key) => key === RequestKeys.initialize);
+        useInitializeLearnerHome.mockReturnValue({
+          data: null,
+          isError: true,
+        });
         getConfig.mockReturnValue({});
         render(<IntlProvider locale="en" messages={messages}><App /></IntlProvider>);
       });
@@ -119,7 +117,6 @@ describe('App router component', () => {
     });
     describe('refresh failure', () => {
       beforeEach(() => {
-        reduxHooks.useRequestIsFailed.mockImplementation((key) => key === RequestKeys.refreshList);
         getConfig.mockReturnValue({});
         render(<IntlProvider locale="en"><App /></IntlProvider>);
       });
diff --git a/src/containers/AppWrapper/indext.test.tsx b/src/containers/AppWrapper/indext.test.tsx
new file mode 100644
index 000000000..00e882979
--- /dev/null
+++ b/src/containers/AppWrapper/indext.test.tsx
@@ -0,0 +1,15 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import AppWrapper from './index';
+
+describe('AppWrapper', () => {
+  it('should render children without modification', () => {
+    render(
+      <AppWrapper>
+        <div>Test Child</div>
+      </AppWrapper>,
+    );
+
+    expect(screen.getByText('Test Child')).toBeInTheDocument();
+  });
+});
diff --git a/src/containers/CourseCard/components/CourseCardActions/BeginCourseButton.jsx b/src/containers/CourseCard/components/CourseCardActions/BeginCourseButton.jsx
index 559b1be23..32088179b 100644
--- a/src/containers/CourseCard/components/CourseCardActions/BeginCourseButton.jsx
+++ b/src/containers/CourseCard/components/CourseCardActions/BeginCourseButton.jsx
@@ -1,21 +1,29 @@
-import React from 'react';
+import React, { useMemo } from 'react';
 import PropTypes from 'prop-types';
 
 import { useIntl } from '@edx/frontend-platform/i18n';
+import { EXECUTIVE_EDUCATION_COURSE_MODES } from 'data/constants/course';
 
 import track from 'tracking';
-import { reduxHooks } from 'hooks';
+import { useCourseData, useCourseTrackingEvent } from 'hooks';
+import { useInitializeLearnerHome } from 'data/hooks';
 import useActionDisabledState from '../hooks';
 import ActionButton from './ActionButton';
 import messages from './messages';
 
 export const BeginCourseButton = ({ cardId }) => {
   const { formatMessage } = useIntl();
-  const { homeUrl } = reduxHooks.useCardCourseRunData(cardId);
-  const execEdTrackingParam = reduxHooks.useCardExecEdTrackingParam(cardId);
+  const { data: learnerData } = useInitializeLearnerHome();
+  const courseData = useCourseData(cardId);
+  const homeUrl = courseData?.courseRun?.homeUrl;
+  const execEdTrackingParam = useMemo(() => {
+    const isExecEd2UCourse = EXECUTIVE_EDUCATION_COURSE_MODES.includes(courseData.enrollment.mode);
+    const { authOrgId } = learnerData.enterpriseDashboard || {};
+    return isExecEd2UCourse ? `?org_id=${authOrgId}` : '';
+  }, [courseData.enrollment.mode, learnerData.enterpriseDashboard]);
   const { disableBeginCourse } = useActionDisabledState(cardId);
 
-  const handleClick = reduxHooks.useTrackCourseEvent(
+  const handleClick = useCourseTrackingEvent(
     track.course.enterCourseClicked,
     cardId,
     homeUrl + execEdTrackingParam,
diff --git a/src/containers/CourseCard/components/CourseCardActions/BeginCourseButton.test.jsx b/src/containers/CourseCard/components/CourseCardActions/BeginCourseButton.test.jsx
index 8b5ea02bb..aedd64b12 100644
--- a/src/containers/CourseCard/components/CourseCardActions/BeginCourseButton.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardActions/BeginCourseButton.test.jsx
@@ -1,36 +1,42 @@
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
-import { reduxHooks } from 'hooks';
 import track from 'tracking';
+import { useCourseData, useCourseTrackingEvent } from 'hooks';
 import useActionDisabledState from '../hooks';
 import BeginCourseButton from './BeginCourseButton';
 
+jest.mock('hooks', () => ({
+  useCourseData: jest.fn().mockReturnValue({
+    enrollment: { mode: 'executive-education' },
+    courseRun: { homeUrl: 'home-url' },
+  }),
+  useCourseTrackingEvent: jest.fn().mockReturnValue({
+    trackCourseEvent: jest.fn(),
+  }),
+}));
+
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn().mockReturnValue({
+    data: {
+      enterpriseDashboard: {
+        authOrgId: 'test-org-id',
+      },
+    },
+  }),
+}));
+
 jest.mock('tracking', () => ({
   course: {
     enterCourseClicked: jest.fn().mockName('segment.enterCourseClicked'),
   },
 }));
 
-jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardCourseRunData: jest.fn(),
-    useCardExecEdTrackingParam: jest.fn(),
-    useTrackCourseEvent: jest.fn(),
-  },
-}));
-
 jest.mock('../hooks', () => jest.fn(() => ({ disableBeginCourse: false })));
 
 jest.mock('./ActionButton/hooks', () => jest.fn(() => false));
 
 const homeUrl = 'home-url';
-reduxHooks.useCardCourseRunData.mockReturnValue({ homeUrl });
-const execEdPath = (cardId) => `exec-ed-tracking-path=${cardId}`;
-reduxHooks.useCardExecEdTrackingParam.mockImplementation(execEdPath);
-reduxHooks.useTrackCourseEvent.mockImplementation(
-  (eventName, cardId, url) => ({ trackCourseEvent: { eventName, cardId, url } }),
-);
 
 const props = {
   cardId: 'cardId',
@@ -45,11 +51,7 @@ describe('BeginCourseButton', () => {
   describe('initiliaze hooks', () => {
     it('initializes course run data with cardId', () => {
       renderComponent();
-      expect(reduxHooks.useCardCourseRunData).toHaveBeenCalledWith(props.cardId);
-    });
-    it('loads exec education path param', () => {
-      renderComponent();
-      expect(reduxHooks.useCardExecEdTrackingParam).toHaveBeenCalledWith(props.cardId);
+      expect(useCourseData).toHaveBeenCalledWith(props.cardId);
     });
     it('loads disabled states for begin action from action hooks', () => {
       renderComponent();
@@ -73,15 +75,15 @@ describe('BeginCourseButton', () => {
         expect(button).not.toHaveClass('disabled');
         expect(button).not.toHaveAttribute('aria-disabled', 'true');
       });
-      it('should track enter course clicked event on click, with exec ed param', async () => {
+      it('should track enter course clicked event on click, with exec ed param', () => {
         renderComponent();
         const user = userEvent.setup();
         const button = screen.getByRole('button', { name: 'Begin Course' });
         user.click(button);
-        expect(reduxHooks.useTrackCourseEvent).toHaveBeenCalledWith(
+        expect(useCourseTrackingEvent).toHaveBeenCalledWith(
           track.course.enterCourseClicked,
           props.cardId,
-          homeUrl + execEdPath(props.cardId),
+          `${homeUrl}?org_id=test-org-id`,
         );
       });
     });
diff --git a/src/containers/CourseCard/components/CourseCardActions/ResumeButton.jsx b/src/containers/CourseCard/components/CourseCardActions/ResumeButton.jsx
index 03c3a2d50..3d5c344b4 100644
--- a/src/containers/CourseCard/components/CourseCardActions/ResumeButton.jsx
+++ b/src/containers/CourseCard/components/CourseCardActions/ResumeButton.jsx
@@ -1,21 +1,29 @@
-import React from 'react';
+import React, { useMemo } from 'react';
 import PropTypes from 'prop-types';
 
 import { useIntl } from '@edx/frontend-platform/i18n';
 
+import { EXECUTIVE_EDUCATION_COURSE_MODES } from 'data/constants/course';
 import track from 'tracking';
-import { reduxHooks } from 'hooks';
+import { useCourseTrackingEvent, useCourseData } from 'hooks';
+import { useInitializeLearnerHome } from 'data/hooks';
 import useActionDisabledState from '../hooks';
 import ActionButton from './ActionButton';
 import messages from './messages';
 
 export const ResumeButton = ({ cardId }) => {
   const { formatMessage } = useIntl();
-  const { resumeUrl } = reduxHooks.useCardCourseRunData(cardId);
-  const execEdTrackingParam = reduxHooks.useCardExecEdTrackingParam(cardId);
+  const { data: learnerData } = useInitializeLearnerHome();
+  const courseData = useCourseData(cardId);
+  const resumeUrl = courseData?.courseRun?.resumeUrl;
+  const execEdTrackingParam = useMemo(() => {
+    const isExecEd2UCourse = EXECUTIVE_EDUCATION_COURSE_MODES.includes(courseData.enrollment.mode);
+    const { authOrgId } = learnerData.enterpriseDashboard || {};
+    return isExecEd2UCourse ? `?org_id=${authOrgId}` : '';
+  }, [courseData.enrollment.mode, learnerData.enterpriseDashboard]);
   const { disableResumeCourse } = useActionDisabledState(cardId);
 
-  const handleClick = reduxHooks.useTrackCourseEvent(
+  const handleClick = useCourseTrackingEvent(
     track.course.enterCourseClicked,
     cardId,
     resumeUrl + execEdTrackingParam,
diff --git a/src/containers/CourseCard/components/CourseCardActions/ResumeButton.test.jsx b/src/containers/CourseCard/components/CourseCardActions/ResumeButton.test.jsx
index 5728b2fda..b6db87fdd 100644
--- a/src/containers/CourseCard/components/CourseCardActions/ResumeButton.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardActions/ResumeButton.test.jsx
@@ -1,36 +1,47 @@
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
+import { useCourseTrackingEvent, useCourseData } from 'hooks';
 
-import { reduxHooks } from 'hooks';
 import track from 'tracking';
 import useActionDisabledState from '../hooks';
 import ResumeButton from './ResumeButton';
 
+const authOrgId = 'auth-org-id';
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn().mockReturnValue({
+    data: {
+      enterpriseDashboard: {
+        authOrgId,
+      },
+    },
+  }),
+}));
+
+jest.mock('hooks', () => ({
+  useCourseData: jest.fn().mockReturnValue({
+    enrollment: { mode: 'executive-education' },
+    courseRun: { homeUrl: 'home-url' },
+  }),
+  useCourseTrackingEvent: jest.fn().mockReturnValue({
+    trackCourseEvent: jest.fn(),
+  }),
+}));
+
 jest.mock('tracking', () => ({
   course: {
     enterCourseClicked: jest.fn().mockName('segment.enterCourseClicked'),
   },
 }));
 
-jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardCourseRunData: jest.fn(),
-    useCardExecEdTrackingParam: jest.fn(),
-    useTrackCourseEvent: jest.fn(),
-  },
-}));
 jest.mock('../hooks', () => jest.fn(() => ({ disableResumeCourse: false })));
 
 jest.mock('./ActionButton/hooks', () => jest.fn(() => false));
 
-const resumeUrl = 'resume-url';
-reduxHooks.useCardCourseRunData.mockReturnValue({ resumeUrl });
-const execEdPath = (cardId) => `exec-ed-tracking-path=${cardId}`;
-reduxHooks.useCardExecEdTrackingParam.mockImplementation(execEdPath);
-reduxHooks.useTrackCourseEvent.mockImplementation(
-  (eventName, cardId, url) => ({ trackCourseEvent: { eventName, cardId, url } }),
-);
+useCourseData.mockReturnValue({
+  enrollment: { mode: 'executive-education' },
+  courseRun: { resumeUrl: 'home-url' },
+});
 
 describe('ResumeButton', () => {
   const props = {
@@ -39,10 +50,7 @@ describe('ResumeButton', () => {
   describe('initialize hooks', () => {
     beforeEach(() => render(<IntlProvider locale="en"><ResumeButton {...props} /></IntlProvider>));
     it('initializes course run data with cardId', () => {
-      expect(reduxHooks.useCardCourseRunData).toHaveBeenCalledWith(props.cardId);
-    });
-    it('loads exec education path param', () => {
-      expect(reduxHooks.useCardExecEdTrackingParam).toHaveBeenCalledWith(props.cardId);
+      expect(useCourseData).toHaveBeenCalledWith(props.cardId);
     });
     it('loads disabled states for resume action from action hooks', () => {
       expect(useActionDisabledState).toHaveBeenCalledWith(props.cardId);
@@ -73,10 +81,10 @@ describe('ResumeButton', () => {
         const user = userEvent.setup();
         const button = screen.getByRole('button', { name: 'Resume' });
         user.click(button);
-        expect(reduxHooks.useTrackCourseEvent).toHaveBeenCalledWith(
+        expect(useCourseTrackingEvent).toHaveBeenCalledWith(
           track.course.enterCourseClicked,
           props.cardId,
-          resumeUrl + execEdPath(props.cardId),
+          `home-url?org_id=${authOrgId}`,
         );
       });
     });
diff --git a/src/containers/CourseCard/components/CourseCardActions/SelectSessionButton.jsx b/src/containers/CourseCard/components/CourseCardActions/SelectSessionButton.jsx
index 5762a1a6f..2e27ba153 100644
--- a/src/containers/CourseCard/components/CourseCardActions/SelectSessionButton.jsx
+++ b/src/containers/CourseCard/components/CourseCardActions/SelectSessionButton.jsx
@@ -3,7 +3,7 @@ import PropTypes from 'prop-types';
 
 import { useIntl } from '@edx/frontend-platform/i18n';
 
-import { reduxHooks } from 'hooks';
+import { useSelectSessionModal } from 'data/context';
 import useActionDisabledState from '../hooks';
 import ActionButton from './ActionButton';
 import messages from './messages';
@@ -11,11 +11,11 @@ import messages from './messages';
 export const SelectSessionButton = ({ cardId }) => {
   const { formatMessage } = useIntl();
   const { disableSelectSession } = useActionDisabledState(cardId);
-  const openSessionModal = reduxHooks.useUpdateSelectSessionModalCallback(cardId);
+  const { updateSelectSessionModal } = useSelectSessionModal();
   return (
     <ActionButton
       disabled={disableSelectSession}
-      onClick={openSessionModal}
+      onClick={() => updateSelectSessionModal(cardId)}
     >
       {formatMessage(messages.selectSession)}
     </ActionButton>
diff --git a/src/containers/CourseCard/components/CourseCardActions/SelectSessionButton.test.jsx b/src/containers/CourseCard/components/CourseCardActions/SelectSessionButton.test.jsx
index ba9e21ccf..8fc9d7dcd 100644
--- a/src/containers/CourseCard/components/CourseCardActions/SelectSessionButton.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardActions/SelectSessionButton.test.jsx
@@ -1,16 +1,16 @@
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
+import { useSelectSessionModal } from 'data/context';
 
-import { reduxHooks } from 'hooks';
 import useActionDisabledState from '../hooks';
 
 import SelectSessionButton from './SelectSessionButton';
 
-jest.mock('hooks', () => ({
-  reduxHooks: {
-    useUpdateSelectSessionModalCallback: jest.fn(),
-  },
+jest.mock('data/context', () => ({
+  useSelectSessionModal: jest.fn().mockReturnValue({
+    updateSelectSessionModal: jest.fn(),
+  }),
 }));
 jest.mock('../hooks', () => jest.fn(() => ({ disableSelectSession: false })));
 
@@ -33,11 +33,15 @@ describe('SelectSessionButton', () => {
   });
   describe('on click', () => {
     it('should call openSessionModal', async () => {
+      const mockedUpdateSelectSessionModal = jest.fn();
+      useSelectSessionModal.mockReturnValue({
+        updateSelectSessionModal: mockedUpdateSelectSessionModal,
+      });
       render(<IntlProvider locale="en"><SelectSessionButton {...props} /></IntlProvider>);
       const user = userEvent.setup();
       const button = screen.getByRole('button', { name: 'Select Session' });
       await user.click(button);
-      expect(reduxHooks.useUpdateSelectSessionModalCallback).toHaveBeenCalledWith(props.cardId);
+      expect(mockedUpdateSelectSessionModal).toHaveBeenCalledWith(props.cardId);
     });
   });
 });
diff --git a/src/containers/CourseCard/components/CourseCardActions/ViewCourseButton.jsx b/src/containers/CourseCard/components/CourseCardActions/ViewCourseButton.jsx
index ef74b0dc4..87e7335d3 100644
--- a/src/containers/CourseCard/components/CourseCardActions/ViewCourseButton.jsx
+++ b/src/containers/CourseCard/components/CourseCardActions/ViewCourseButton.jsx
@@ -4,17 +4,18 @@ import PropTypes from 'prop-types';
 import { useIntl } from '@edx/frontend-platform/i18n';
 
 import track from 'tracking';
-import { reduxHooks } from 'hooks';
+import { useCourseTrackingEvent, useCourseData } from 'hooks';
 import useActionDisabledState from '../hooks';
 import ActionButton from './ActionButton';
 import messages from './messages';
 
 export const ViewCourseButton = ({ cardId }) => {
   const { formatMessage } = useIntl();
-  const { homeUrl } = reduxHooks.useCardCourseRunData(cardId);
+  const courseData = useCourseData(cardId);
+  const homeUrl = courseData?.courseRun?.homeUrl;
   const { disableViewCourse } = useActionDisabledState(cardId);
 
-  const handleClick = reduxHooks.useTrackCourseEvent(
+  const handleClick = useCourseTrackingEvent(
     track.course.enterCourseClicked,
     cardId,
     homeUrl,
diff --git a/src/containers/CourseCard/components/CourseCardActions/ViewCourseButton.test.jsx b/src/containers/CourseCard/components/CourseCardActions/ViewCourseButton.test.jsx
index a9b2f654f..d5cbc23e3 100644
--- a/src/containers/CourseCard/components/CourseCardActions/ViewCourseButton.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardActions/ViewCourseButton.test.jsx
@@ -1,24 +1,27 @@
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
+import { useCourseTrackingEvent } from 'hooks';
 
 import track from 'tracking';
-import { reduxHooks } from 'hooks';
 import useActionDisabledState from '../hooks';
 import ViewCourseButton from './ViewCourseButton';
 
+jest.mock('hooks', () => ({
+  useCourseData: jest.fn().mockReturnValue({
+    courseRun: { homeUrl: 'homeUrl' },
+  }),
+  useCourseTrackingEvent: jest.fn().mockReturnValue({
+    trackCourseEvent: jest.fn(),
+  }),
+}));
+
 jest.mock('tracking', () => ({
   course: {
     enterCourseClicked: jest.fn().mockName('segment.enterCourseClicked'),
   },
 }));
 
-jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardCourseRunData: jest.fn(() => ({ homeUrl: 'homeUrl' })),
-    useTrackCourseEvent: jest.fn(),
-  },
-}));
 jest.mock('../hooks', () => jest.fn(() => ({ disableViewCourse: false })));
 
 jest.mock('./ActionButton/hooks', () => jest.fn(() => false));
@@ -35,15 +38,18 @@ describe('ViewCourseButton', () => {
     expect(button).not.toHaveAttribute('aria-disabled', 'true');
   });
   it('calls trackCourseEvent on click', async () => {
+    const mockedTrackCourseEvent = jest.fn();
+    useCourseTrackingEvent.mockReturnValue(mockedTrackCourseEvent);
     render(<IntlProvider locale="en"><ViewCourseButton {...defaultProps} /></IntlProvider>);
     const user = userEvent.setup();
     const button = screen.getByRole('button', { name: 'View Course' });
     await user.click(button);
-    expect(reduxHooks.useTrackCourseEvent).toHaveBeenCalledWith(
+    expect(useCourseTrackingEvent).toHaveBeenCalledWith(
       track.course.enterCourseClicked,
       defaultProps.cardId,
       homeUrl,
     );
+    expect(mockedTrackCourseEvent).toHaveBeenCalled();
   });
   it('learner cannot view course', () => {
     useActionDisabledState.mockReturnValueOnce({ disableViewCourse: true });
diff --git a/src/containers/CourseCard/components/CourseCardActions/index.jsx b/src/containers/CourseCard/components/CourseCardActions/index.jsx
index 5f4a34fa5..4806262ac 100644
--- a/src/containers/CourseCard/components/CourseCardActions/index.jsx
+++ b/src/containers/CourseCard/components/CourseCardActions/index.jsx
@@ -3,7 +3,7 @@ import PropTypes from 'prop-types';
 
 import { ActionRow } from '@openedx/paragon';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData, useEntitlementInfo } from 'hooks';
 
 import CourseCardActionSlot from 'plugin-slots/CourseCardActionSlot';
 import SelectSessionButton from './SelectSessionButton';
@@ -12,11 +12,10 @@ import ResumeButton from './ResumeButton';
 import ViewCourseButton from './ViewCourseButton';
 
 export const CourseCardActions = ({ cardId }) => {
-  const { isEntitlement, isFulfilled } = reduxHooks.useCardEntitlementData(cardId);
-  const {
-    hasStarted,
-  } = reduxHooks.useCardEnrollmentData(cardId);
-  const { isArchived } = reduxHooks.useCardCourseRunData(cardId);
+  const cardData = useCourseData(cardId);
+  const hasStarted = cardData.enrollment.hasStarted || false;
+  const { isEntitlement, isFulfilled } = useEntitlementInfo(cardData);
+  const isArchived = cardData.courseRun.isArchived || false;
 
   return (
     <ActionRow data-test-id="CourseCardActions">
diff --git a/src/containers/CourseCard/components/CourseCardActions/index.test.jsx b/src/containers/CourseCard/components/CourseCardActions/index.test.jsx
index 1cbacc362..4d8948be7 100644
--- a/src/containers/CourseCard/components/CourseCardActions/index.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardActions/index.test.jsx
@@ -1,15 +1,10 @@
 import { render, screen } from '@testing-library/react';
-import { reduxHooks } from 'hooks';
-
+import { useCourseData } from 'hooks';
 import CourseCardActions from '.';
 
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardCourseRunData: jest.fn(),
-    useCardEnrollmentData: jest.fn(),
-    useCardEntitlementData: jest.fn(),
-    useMasqueradeData: jest.fn(),
-  },
+  ...jest.requireActual('hooks'),
+  useCourseData: jest.fn(),
 }));
 
 jest.mock('plugin-slots/CourseCardActionSlot', () => jest.fn(() => <div>CourseCardActionSlot</div>));
@@ -24,26 +19,22 @@ const props = { cardId };
 describe('CourseCardActions', () => {
   const mockHooks = ({
     isEntitlement = false,
-    isExecEd2UCourse = false,
     isFulfilled = false,
     isArchived = false,
-    isVerified = false,
     hasStarted = false,
-    isMasquerading = false,
   } = {}) => {
-    reduxHooks.useCardEntitlementData.mockReturnValueOnce({ isEntitlement, isFulfilled });
-    reduxHooks.useCardCourseRunData.mockReturnValueOnce({ isArchived });
-    reduxHooks.useCardEnrollmentData.mockReturnValueOnce({ isExecEd2UCourse, isVerified, hasStarted });
-    reduxHooks.useMasqueradeData.mockReturnValueOnce({ isMasquerading });
+    useCourseData.mockReturnValueOnce({
+      enrollment: { hasStarted },
+      courseRun: { isArchived },
+      entitlement: isEntitlement !== null ? { isEntitlement, isFulfilled } : null,
+    });
   };
   const renderComponent = () => render(<CourseCardActions {...props} />);
   describe('hooks', () => {
-    it('initializes redux hooks', () => {
+    it('initializes hooks', () => {
       mockHooks();
       renderComponent();
-      expect(reduxHooks.useCardEntitlementData).toHaveBeenCalledWith(cardId);
-      expect(reduxHooks.useCardEnrollmentData).toHaveBeenCalledWith(cardId);
-      expect(reduxHooks.useCardCourseRunData).toHaveBeenCalledWith(cardId);
+      expect(useCourseData).toHaveBeenCalledWith(cardId);
     });
   });
   describe('output', () => {
@@ -63,7 +54,7 @@ describe('CourseCardActions', () => {
     });
     describe('not entitlement, verified, or exec ed', () => {
       it('renders CourseCardActionSlot and ViewCourseButton for archived courses', () => {
-        mockHooks({ isArchived: true });
+        mockHooks({ isArchived: true, isEntitlement: null });
         renderComponent();
         const CourseCardActionSlot = screen.getByText('CourseCardActionSlot');
         expect(CourseCardActionSlot).toBeInTheDocument();
@@ -72,7 +63,7 @@ describe('CourseCardActions', () => {
       });
       describe('unstarted courses', () => {
         it('renders CourseCardActionSlot and BeginCourseButton', () => {
-          mockHooks();
+          mockHooks({ isEntitlement: null });
           renderComponent();
           const CourseCardActionSlot = screen.getByText('CourseCardActionSlot');
           expect(CourseCardActionSlot).toBeInTheDocument();
@@ -82,7 +73,7 @@ describe('CourseCardActions', () => {
       });
       describe('active courses (started, and not archived)', () => {
         it('renders CourseCardActionSlot and ResumeButton', () => {
-          mockHooks({ hasStarted: true });
+          mockHooks({ hasStarted: true, isEntitlement: null });
           renderComponent();
           const CourseCardActionSlot = screen.getByText('CourseCardActionSlot');
           expect(CourseCardActionSlot).toBeInTheDocument();
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CertificateBanner.jsx b/src/containers/CourseCard/components/CourseCardBanners/CertificateBanner.jsx
index 556628d5a..8baa07f65 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CertificateBanner.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CertificateBanner.jsx
@@ -1,12 +1,14 @@
 /* eslint-disable max-len */
-import React from 'react';
+import React, { useMemo } from 'react';
 import PropTypes from 'prop-types';
 
 import { MailtoLink, Hyperlink } from '@openedx/paragon';
 import { CheckCircle } from '@openedx/paragon/icons';
 import { useIntl } from '@edx/frontend-platform/i18n';
+import { baseAppUrl } from 'data/services/lms/urls';
 
-import { utilHooks, reduxHooks } from 'hooks';
+import { useInitializeLearnerHome } from 'data/hooks';
+import { utilHooks, useCourseData } from 'hooks';
 import Banner from 'components/Banner';
 
 import messages from './messages';
@@ -14,15 +16,32 @@ import messages from './messages';
 const { useFormatDate } = utilHooks;
 
 export const CertificateBanner = ({ cardId }) => {
-  const certificate = reduxHooks.useCardCertificateData(cardId);
+  const { data: learnerHomeData } = useInitializeLearnerHome();
+  const courseData = useCourseData(cardId);
   const {
-    isAudit,
-    isVerified,
-  } = reduxHooks.useCardEnrollmentData(cardId);
-  const { isPassing } = reduxHooks.useCardGradeData(cardId);
-  const { isArchived } = reduxHooks.useCardCourseRunData(cardId);
-  const { minPassingGrade, progressUrl } = reduxHooks.useCardCourseRunData(cardId);
-  const { supportEmail, billingEmail } = reduxHooks.usePlatformSettingsData();
+    certificate = {},
+    isVerified = false,
+    isAudit = false,
+    isPassing = false,
+    isArchived = false,
+    minPassingGrade = 0,
+    progressUrl = '',
+  } = useMemo(() => ({
+    isVerified: courseData?.enrollment?.isVerified,
+    isAudit: courseData?.enrollment?.isAudit,
+    certificate: courseData?.certificate || {},
+    isPassing: courseData?.gradeData?.isPassing,
+    isArchived: courseData?.courseRun?.isArchived,
+    minPassingGrade: Math.floor(courseData?.courseRun?.minPassingGrade || 0 * 100),
+    progressUrl: baseAppUrl(courseData?.courseRun?.progressUrl || ''),
+  }), [courseData]);
+  const { supportEmail, billingEmail } = useMemo(
+    () => ({
+      supportEmail: learnerHomeData?.platformSettings?.supportEmail,
+      billingEmail: learnerHomeData?.platformSettings?.billingEmail,
+    }),
+    [learnerHomeData],
+  );
   const { formatMessage } = useIntl();
   const formatDate = useFormatDate();
 
@@ -75,7 +94,7 @@ export const CertificateBanner = ({ cardId }) => {
       </Banner>
     );
   }
-  if (certificate.isEarnedButUnavailable) {
+  if (certificate.isEarned && new Date(certificate.availableDate) > new Date()) {
     return (
       <Banner>
         {formatMessage(
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CertificateBanner.test.jsx b/src/containers/CourseCard/components/CourseCardBanners/CertificateBanner.test.jsx
index 4575a8aeb..993ba9943 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CertificateBanner.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CertificateBanner.test.jsx
@@ -1,20 +1,20 @@
+import React from 'react';
 import { render, screen } from '@testing-library/react';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
+import { useInitializeLearnerHome } from 'data/hooks';
 import CertificateBanner from './CertificateBanner';
 
 jest.mock('hooks', () => ({
   utilHooks: {
     useFormatDate: jest.fn(() => date => date),
   },
-  reduxHooks: {
-    useCardCertificateData: jest.fn(),
-    useCardCourseRunData: jest.fn(),
-    useCardEnrollmentData: jest.fn(),
-    useCardGradeData: jest.fn(),
-    usePlatformSettingsData: jest.fn(),
-  },
+  useCourseData: jest.fn(),
+}));
+
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn(),
 }));
 
 const defaultCertificate = {
@@ -35,9 +35,14 @@ const supportEmail = 'suport@email.com';
 const billingEmail = 'billing@email.com';
 
 describe('CertificateBanner', () => {
-  reduxHooks.useCardCourseRunData.mockReturnValue({
-    minPassingGrade: 0.8,
-    progressUrl: 'progressUrl',
+  useCourseData.mockReturnValue({
+    enrollment: {},
+    certificate: {},
+    gradeData: {},
+    courseRun: {
+      minPassingGrade: 0.8,
+      progressUrl: 'progressUrl',
+    },
   });
   const createWrapper = ({
     certificate = {},
@@ -46,11 +51,17 @@ describe('CertificateBanner', () => {
     courseRun = {},
     platformSettings = {},
   }) => {
-    reduxHooks.useCardGradeData.mockReturnValueOnce({ ...defaultGrade, ...grade });
-    reduxHooks.useCardCertificateData.mockReturnValueOnce({ ...defaultCertificate, ...certificate });
-    reduxHooks.useCardEnrollmentData.mockReturnValueOnce({ ...defaultEnrollment, ...enrollment });
-    reduxHooks.useCardCourseRunData.mockReturnValueOnce({ ...defaultCourseRun, ...courseRun });
-    reduxHooks.usePlatformSettingsData.mockReturnValueOnce({ ...defaultPlatformSettings, ...platformSettings });
+    useCourseData.mockReturnValue({
+      enrollment: { ...defaultEnrollment, ...enrollment },
+      certificate: { ...defaultCertificate, ...certificate },
+      gradeData: { ...defaultGrade, ...grade },
+      courseRun: {
+        ...defaultCourseRun,
+        ...courseRun,
+      },
+    });
+    const lernearData = { data: { platformSettings: { ...defaultPlatformSettings, ...platformSettings } } };
+    useInitializeLearnerHome.mockReturnValue(lernearData);
     return render(<IntlProvider locale="en"><CertificateBanner {...props} /></IntlProvider>);
   };
   beforeEach(() => {
@@ -222,7 +233,8 @@ describe('CertificateBanner', () => {
         isPassing: true,
       },
       certificate: {
-        isEarnedButUnavailable: true,
+        isEarned: true,
+        availableDate: '10/20/3030',
       },
     });
     const banner = screen.getByRole('alert');
@@ -239,4 +251,27 @@ describe('CertificateBanner', () => {
     const banner = screen.queryByRole('alert');
     expect(banner).toBeNull();
   });
+  it('should use default values when courseData is empty or undefined', () => {
+    useCourseData.mockReturnValue({});
+    const lernearData = { data: { platformSettings: { supportEmail } } };
+    useInitializeLearnerHome.mockReturnValue(lernearData);
+    render(<IntlProvider locale="en"><CertificateBanner cardId="test-card" /></IntlProvider>);
+
+    const mockedUseMemo = jest.spyOn(React, 'useMemo');
+    const useMemoCall = mockedUseMemo.mock.calls.find(call => call[1].some(dep => dep === undefined || dep === null));
+
+    if (useMemoCall) {
+      const result = useMemoCall[0]();
+
+      expect(result.certificate).toEqual({});
+      expect(result.isVerified).toBe(false);
+      expect(result.isAudit).toBe(false);
+      expect(result.isPassing).toBe(false);
+      expect(result.isArchived).toBe(false);
+      expect(result.minPassingGrade).toBe(0);
+      expect(result.progressUrl).toBeDefined();
+    }
+
+    mockedUseMemo.mockRestore();
+  });
 });
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CourseBanner.jsx b/src/containers/CourseCard/components/CourseCardBanners/CourseBanner.jsx
index db26b1c00..0e3f9f6b8 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CourseBanner.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CourseBanner.jsx
@@ -1,21 +1,26 @@
 /* eslint-disable max-len */
-import React from 'react';
+import React, { useMemo } from 'react';
 import PropTypes from 'prop-types';
 import { Hyperlink } from '@openedx/paragon';
 import { useIntl } from '@edx/frontend-platform/i18n';
 
-import { utilHooks, reduxHooks } from 'hooks';
+import { utilHooks, useCourseData } from 'hooks';
 import Banner from 'components/Banner';
 import messages from './messages';
 
 export const CourseBanner = ({ cardId }) => {
+  const { formatMessage } = useIntl();
+  const courseData = useCourseData(cardId);
   const {
-    isVerified,
-    isAuditAccessExpired,
+    isVerified = false,
+    isAuditAccessExpired = false,
     coursewareAccess = {},
-  } = reduxHooks.useCardEnrollmentData(cardId);
-  const courseRun = reduxHooks.useCardCourseRunData(cardId);
-  const { formatMessage } = useIntl();
+  } = useMemo(() => ({
+    isVerified: courseData.enrollment?.isVerified,
+    isAuditAccessExpired: courseData.enrollment?.isAuditAccessExpired,
+    coursewareAccess: courseData.enrollment?.coursewareAccess || {},
+  }), [courseData]);
+  const courseRun = courseData?.courseRun || {};
   const formatDate = utilHooks.useFormatDate();
 
   const { hasUnmetPrerequisites, isStaff, isTooEarly } = coursewareAccess;
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CourseBanner.test.jsx b/src/containers/CourseCard/components/CourseCardBanners/CourseBanner.test.jsx
index 42d40331c..587d5e8a9 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CourseBanner.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CourseBanner.test.jsx
@@ -1,20 +1,17 @@
 import { render, screen } from '@testing-library/react';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 import { formatMessage } from 'testUtils';
 import { CourseBanner } from './CourseBanner';
 
 import messages from './messages';
 
 jest.mock('hooks', () => ({
+  useCourseData: jest.fn(),
   utilHooks: {
     useFormatDate: () => date => date,
   },
-  reduxHooks: {
-    useCardCourseRunData: jest.fn(),
-    useCardEnrollmentData: jest.fn(),
-  },
 }));
 
 const cardId = 'test-card-id';
@@ -39,13 +36,15 @@ const renderCourseBanner = (overrides = {}) => {
     courseRun = {},
     enrollment = {},
   } = overrides;
-  reduxHooks.useCardCourseRunData.mockReturnValueOnce({
-    ...courseRunData,
-    ...courseRun,
-  });
-  reduxHooks.useCardEnrollmentData.mockReturnValueOnce({
-    ...enrollmentData,
-    ...enrollment,
+  useCourseData.mockReturnValue({
+    courseRun: {
+      ...courseRunData,
+      ...courseRun,
+    },
+    enrollment: {
+      ...enrollmentData,
+      ...enrollment,
+    },
   });
   return render(<IntlProvider locale="en"><CourseBanner cardId={cardId} /></IntlProvider>);
 };
@@ -53,13 +52,20 @@ const renderCourseBanner = (overrides = {}) => {
 describe('CourseBanner', () => {
   it('initializes data with course number from enrollment, course and course run data', () => {
     renderCourseBanner();
-    expect(reduxHooks.useCardCourseRunData).toHaveBeenCalledWith(cardId);
-    expect(reduxHooks.useCardEnrollmentData).toHaveBeenCalledWith(cardId);
+    expect(useCourseData).toHaveBeenCalledWith(cardId);
   });
   it('no display if learner is verified', () => {
     renderCourseBanner({ enrollment: { isVerified: true } });
     expect(screen.queryByRole('alert')).toBeNull();
   });
+  it('should use default values when enrollment data is undefined', () => {
+    renderCourseBanner({
+      enrollment: undefined,
+      courseRun: {},
+    });
+
+    expect(useCourseData).toHaveBeenCalledWith('test-card-id');
+  });
   describe('audit access expired', () => {
     it('should display correct message and link', () => {
       renderCourseBanner({ enrollment: { isAuditAccessExpired: true } });
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/hooks.js b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/hooks.js
index 89e92ebef..dc9ebb320 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/hooks.js
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/hooks.js
@@ -1,6 +1,8 @@
+import { useMemo } from 'react';
+import { useInitializeLearnerHome } from 'data/hooks';
 import { StrictDict } from 'utils';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 
 import ApprovedContent from './views/ApprovedContent';
 import EligibleContent from './views/EligibleContent';
@@ -15,9 +17,29 @@ export const statusComponents = StrictDict({
 });
 
 export const useCreditBannerData = (cardId) => {
-  const credit = reduxHooks.useCardCreditData(cardId);
-  const { supportEmail } = reduxHooks.usePlatformSettingsData();
-  if (!credit.isEligible) { return null; }
+  const courseData = useCourseData(cardId);
+  const { data: learnerHomeData } = useInitializeLearnerHome();
+  const supportEmail = useMemo(
+    () => (learnerHomeData?.platformSettings?.supportEmail),
+    [learnerHomeData],
+  );
+
+  const credit = useMemo(() => {
+    const creditData = courseData?.credit;
+    if (!creditData || Object.keys(creditData).length === 0) {
+      return { isEligible: false };
+    }
+    return {
+      isEligible: true,
+      providerStatusUrl: creditData.providerStatusUrl,
+      providerName: creditData.providerName,
+      providerId: creditData.providerId,
+      error: creditData.error,
+      purchased: creditData.purchased,
+      requestStatus: creditData.requestStatus,
+    };
+  }, [courseData]);
+  if (!credit.isEligible || !courseData?.credit?.isEligible) { return null; }
 
   const { error, purchased, requestStatus } = credit;
   let ContentComponent = EligibleContent;
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/hooks.test.js b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/hooks.test.js
index 729de8f7d..92d6341f0 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/hooks.test.js
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/hooks.test.js
@@ -1,5 +1,6 @@
 import { keyStore } from 'utils';
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
+import { useInitializeLearnerHome } from 'data/hooks';
 
 import ApprovedContent from './views/ApprovedContent';
 import EligibleContent from './views/EligibleContent';
@@ -9,12 +10,19 @@ import RejectedContent from './views/RejectedContent';
 
 import * as hooks from './hooks';
 
+jest.mock('react', () => ({
+  ...jest.requireActual('react'),
+  useMemo: (fn) => fn(),
+}));
+
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardCreditData: jest.fn(),
-    usePlatformSettingsData: jest.fn(),
-  },
+  useCourseData: jest.fn(),
 }));
+
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn(),
+}));
+
 jest.mock('./views/ApprovedContent', () => 'ApprovedContent');
 jest.mock('./views/EligibleContent', () => 'EligibleContent');
 jest.mock('./views/MustRequestContent', () => 'MustRequestContent');
@@ -34,18 +42,18 @@ const defaultProps = {
 };
 
 const loadHook = (creditData = {}) => {
-  reduxHooks.useCardCreditData.mockReturnValue({ ...defaultProps, ...creditData });
+  useCourseData.mockReturnValue({ credit: { ...defaultProps, ...creditData } });
   out = hooks.useCreditBannerData(cardId);
 };
 
 describe('useCreditBannerData hook', () => {
   beforeEach(() => {
-    reduxHooks.usePlatformSettingsData.mockReturnValue({ supportEmail });
+    useInitializeLearnerHome.mockReturnValue({ data: { platformSettings: { supportEmail } } });
   });
   it('loads card credit data with cardID and loads platform settings data', () => {
     loadHook({ isEligible: false });
-    expect(reduxHooks.useCardCreditData).toHaveBeenCalledWith(cardId);
-    expect(reduxHooks.usePlatformSettingsData).toHaveBeenCalledWith();
+    expect(useCourseData).toHaveBeenCalledWith(cardId);
+    expect(useInitializeLearnerHome).toHaveBeenCalledWith();
   });
   describe('non-credit-eligible learner', () => {
     it('returns null if the learner is not credit eligible', () => {
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/ApprovedContent.jsx b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/ApprovedContent.jsx
index bb334195c..af600851a 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/ApprovedContent.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/ApprovedContent.jsx
@@ -1,17 +1,24 @@
-import React from 'react';
+import React, { useMemo } from 'react';
 import PropTypes from 'prop-types';
 
 import { useIntl } from '@edx/frontend-platform/i18n';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData, useIsMasquerading } from 'hooks';
 import CreditContent from './components/CreditContent';
 import ProviderLink from './components/ProviderLink';
 
 import messages from './messages';
 
 export const ApprovedContent = ({ cardId }) => {
-  const { providerStatusUrl: href, providerName } = reduxHooks.useCardCreditData(cardId);
-  const { isMasquerading } = reduxHooks.useMasqueradeData();
+  const courseData = useCourseData(cardId);
+  const { providerStatusUrl: href, providerName } = useMemo(() => {
+    const creditData = courseData?.credit;
+    return {
+      providerStatusUrl: creditData.providerStatusUrl,
+      providerName: creditData.providerName,
+    };
+  }, [courseData]);
+  const isMasquerading = useIsMasquerading();
   const { formatMessage } = useIntl();
   return (
     <CreditContent
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/ApprovedContent.test.jsx b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/ApprovedContent.test.jsx
index 65cbb7e1e..5b5571896 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/ApprovedContent.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/ApprovedContent.test.jsx
@@ -1,15 +1,13 @@
 import { render, screen } from '@testing-library/react';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 import { formatMessage } from 'testUtils';
-import { reduxHooks } from 'hooks';
+import { useCourseData, useIsMasquerading } from 'hooks';
 import messages from './messages';
 import ApprovedContent from './ApprovedContent';
 
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardCreditData: jest.fn(),
-    useMasqueradeData: jest.fn(),
-  },
+  useCourseData: jest.fn(),
+  useIsMasquerading: jest.fn(),
 }));
 
 const cardId = 'test-card-id';
@@ -17,14 +15,14 @@ const credit = {
   providerStatusUrl: 'test-credit-provider-status-url',
   providerName: 'test-credit-provider-name',
 };
-reduxHooks.useCardCreditData.mockReturnValue(credit);
-reduxHooks.useMasqueradeData.mockReturnValue({ isMasquerading: false });
+useCourseData.mockReturnValue({ credit });
+useIsMasquerading.mockReturnValue(false);
 
 describe('ApprovedContent component', () => {
   describe('hooks', () => {
     it('initializes credit data with cardId', () => {
       render(<IntlProvider locale="en"><ApprovedContent cardId={cardId} /></IntlProvider>);
-      expect(reduxHooks.useCardCreditData).toHaveBeenCalledWith(cardId);
+      expect(useCourseData).toHaveBeenCalledWith(cardId);
     });
   });
   describe('render', () => {
@@ -56,7 +54,7 @@ describe('ApprovedContent component', () => {
     });
     describe('when masquerading', () => {
       beforeEach(() => {
-        reduxHooks.useMasqueradeData.mockReturnValue({ isMasquerading: true });
+        useIsMasquerading.mockReturnValue(true);
         render(<IntlProvider locale="en"><ApprovedContent cardId={cardId} /></IntlProvider>);
       });
 
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/EligibleContent.jsx b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/EligibleContent.jsx
index b38fdec56..585df6ec7 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/EligibleContent.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/EligibleContent.jsx
@@ -3,7 +3,7 @@ import PropTypes from 'prop-types';
 
 import { useIntl } from '@edx/frontend-platform/i18n';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 import track from 'tracking';
 
 import CreditContent from './components/CreditContent';
@@ -11,8 +11,9 @@ import messages from './messages';
 
 export const EligibleContent = ({ cardId }) => {
   const { formatMessage } = useIntl();
-  const { providerName } = reduxHooks.useCardCreditData(cardId);
-  const { courseId } = reduxHooks.useCardCourseRunData(cardId);
+  const courseData = useCourseData(cardId);
+  const providerName = courseData?.credit?.providerName;
+  const courseId = courseData?.courseRun?.courseId;
 
   const onClick = track.credit.purchase(courseId);
   const getCredit = formatMessage(messages.getCredit);
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/EligibleContent.test.jsx b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/EligibleContent.test.jsx
index dfb7d4102..6b2d18d1e 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/EligibleContent.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/EligibleContent.test.jsx
@@ -2,17 +2,14 @@ import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 import track from 'tracking';
 
 import messages from './messages';
 import EligibleContent from './EligibleContent';
 
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardCreditData: jest.fn(),
-    useCardCourseRunData: jest.fn(),
-  },
+  useCourseData: jest.fn(),
 }));
 
 jest.mock('tracking', () => ({
@@ -26,8 +23,7 @@ const courseId = 'test-course-id';
 const credit = {
   providerName: 'test-credit-provider-name',
 };
-reduxHooks.useCardCreditData.mockReturnValue(credit);
-reduxHooks.useCardCourseRunData.mockReturnValue({ courseId });
+useCourseData.mockReturnValue({ credit, courseRun: { courseId } });
 
 const renderEligibleContent = () => render(<IntlProvider locale="en" messages={{}}><EligibleContent cardId={cardId} /></IntlProvider>);
 
@@ -35,11 +31,7 @@ describe('EligibleContent component', () => {
   describe('hooks', () => {
     it('initializes credit data with cardId', () => {
       renderEligibleContent();
-      expect(reduxHooks.useCardCreditData).toHaveBeenCalledWith(cardId);
-    });
-    it('initializes course run data with cardId', () => {
-      renderEligibleContent();
-      expect(reduxHooks.useCardCourseRunData).toHaveBeenCalledWith(cardId);
+      expect(useCourseData).toHaveBeenCalledWith(cardId);
     });
   });
   describe('behavior', () => {
@@ -63,7 +55,7 @@ describe('EligibleContent component', () => {
         expect(eligibleMessage).toHaveTextContent(credit.providerName);
       });
       it('message is formatted eligible message if no provider', () => {
-        reduxHooks.useCardCreditData.mockReturnValue({});
+        useCourseData.mockReturnValue({ credit: {}, courseRun: { courseId } });
         renderEligibleContent();
         const eligibleMessage = screen.getByTestId('credit-msg');
         expect(eligibleMessage).toBeInTheDocument();
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/MustRequestContent.jsx b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/MustRequestContent.jsx
index 082e9143f..7ee5b57c5 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/MustRequestContent.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/MustRequestContent.jsx
@@ -3,7 +3,7 @@ import PropTypes from 'prop-types';
 
 import { useIntl } from '@edx/frontend-platform/i18n';
 
-import { reduxHooks } from 'hooks';
+import { useIsMasquerading } from 'hooks';
 import CreditContent from './components/CreditContent';
 import ProviderLink from './components/ProviderLink';
 import hooks from './hooks';
@@ -13,7 +13,7 @@ import messages from './messages';
 export const MustRequestContent = ({ cardId }) => {
   const { formatMessage } = useIntl();
   const { requestData, createCreditRequest } = hooks.useCreditRequestData(cardId);
-  const { isMasquerading } = reduxHooks.useMasqueradeData();
+  const isMasquerading = useIsMasquerading();
   return (
     <CreditContent
       action={{
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/MustRequestContent.test.jsx b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/MustRequestContent.test.jsx
index 18d42bf8c..b21ad2387 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/MustRequestContent.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/MustRequestContent.test.jsx
@@ -1,8 +1,7 @@
 import { render, screen } from '@testing-library/react';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 import userEvent from '@testing-library/user-event';
-
-import { reduxHooks } from 'hooks';
+import { useCourseData, useIsMasquerading } from 'hooks';
 import messages from './messages';
 import hooks from './hooks';
 import MustRequestContent from './MustRequestContent';
@@ -12,10 +11,8 @@ jest.mock('./hooks', () => ({
 }));
 
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useMasqueradeData: jest.fn(),
-    useCardCreditData: jest.fn(),
-  },
+  useCourseData: jest.fn(),
+  useIsMasquerading: jest.fn(),
 }));
 
 const cardId = 'test-card-id';
@@ -44,10 +41,12 @@ describe('MustRequestContent component', () => {
       requestData,
       createCreditRequest,
     });
-    reduxHooks.useMasqueradeData.mockReturnValue({ isMasquerading: false });
-    reduxHooks.useCardCreditData.mockReturnValue({
-      providerName,
-      providerStatusUrl,
+    useIsMasquerading.mockReturnValue(false);
+    useCourseData.mockReturnValue({
+      credit: {
+        providerName,
+        providerStatusUrl,
+      },
     });
   });
 
@@ -90,7 +89,7 @@ describe('MustRequestContent component', () => {
 
     describe('when masquerading', () => {
       beforeEach(() => {
-        reduxHooks.useMasqueradeData.mockReturnValue({ isMasquerading: true });
+        useIsMasquerading.mockReturnValue(true);
         renderMustRequestContent();
       });
 
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/PendingContent.jsx b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/PendingContent.jsx
index b7b44dcb9..f45ec56a0 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/PendingContent.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/PendingContent.jsx
@@ -3,13 +3,14 @@ import PropTypes from 'prop-types';
 
 import { useIntl } from '@edx/frontend-platform/i18n';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData, useIsMasquerading } from 'hooks';
 import CreditContent from './components/CreditContent';
 import messages from './messages';
 
 export const PendingContent = ({ cardId }) => {
-  const { providerStatusUrl: href, providerName } = reduxHooks.useCardCreditData(cardId);
-  const { isMasquerading } = reduxHooks.useMasqueradeData();
+  const courseData = useCourseData(cardId);
+  const { providerStatusUrl: href, providerName } = courseData?.credit || {};
+  const isMasquerading = useIsMasquerading();
   const { formatMessage } = useIntl();
   return (
     <CreditContent
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/PendingContent.test.jsx b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/PendingContent.test.jsx
index e1fe15108..bb645118e 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/PendingContent.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/PendingContent.test.jsx
@@ -1,23 +1,25 @@
 import { render, screen } from '@testing-library/react';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
-
-import { reduxHooks } from 'hooks';
+import { useCourseData, useIsMasquerading } from 'hooks';
 
 import messages from './messages';
 import PendingContent from './PendingContent';
 
 jest.mock('hooks', () => ({
-  reduxHooks: { useCardCreditData: jest.fn(), useMasqueradeData: jest.fn() },
+  useCourseData: jest.fn(),
+  useIsMasquerading: jest.fn(),
 }));
 
 const cardId = 'test-card-id';
 const providerName = 'test-credit-provider-name';
 const providerStatusUrl = 'test-credit-provider-status-url';
-reduxHooks.useCardCreditData.mockReturnValue({
-  providerName,
-  providerStatusUrl,
+useIsMasquerading.mockReturnValue(false);
+useCourseData.mockReturnValue({
+  credit: {
+    providerName,
+    providerStatusUrl,
+  },
 });
-reduxHooks.useMasqueradeData.mockReturnValue({ isMasquerading: false });
 
 const renderPendingContent = () => render(
   <IntlProvider messages={{}} locale="en">
@@ -28,7 +30,7 @@ describe('PendingContent component', () => {
   describe('hooks', () => {
     it('initializes card credit data with cardId', () => {
       renderPendingContent();
-      expect(reduxHooks.useCardCreditData).toHaveBeenCalledWith(cardId);
+      expect(useCourseData).toHaveBeenCalledWith(cardId);
     });
   });
   describe('behavior', () => {
@@ -56,7 +58,7 @@ describe('PendingContent component', () => {
       });
       describe('when masqueradeData is true', () => {
         it('disables the view details button', () => {
-          reduxHooks.useMasqueradeData.mockReturnValue({ isMasquerading: true });
+          useIsMasquerading.mockReturnValue(true);
           renderPendingContent();
           const button = screen.getByRole('link', { name: messages.viewDetails.defaultMessage });
           expect(button).toHaveClass('disabled');
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/RejectedContent.jsx b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/RejectedContent.jsx
index afd66e788..586919826 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/RejectedContent.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/RejectedContent.jsx
@@ -3,18 +3,19 @@ import PropTypes from 'prop-types';
 
 import { useIntl } from '@edx/frontend-platform/i18n';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 import CreditContent from './components/CreditContent';
 import ProviderLink from './components/ProviderLink';
 import messages from './messages';
 
 export const RejectedContent = ({ cardId }) => {
-  const credit = reduxHooks.useCardCreditData(cardId);
+  const courseData = useCourseData(cardId);
+  const credit = courseData?.credit;
   const { formatMessage } = useIntl();
   return (
     <CreditContent
       message={formatMessage(messages.rejected, {
-        providerName: credit.providerName,
+        providerName: credit?.providerName,
         linkToProviderSite: (<ProviderLink cardId={cardId} />),
       })}
     />
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/RejectedContent.test.jsx b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/RejectedContent.test.jsx
index 03df3ba30..eba071a95 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/RejectedContent.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/RejectedContent.test.jsx
@@ -1,13 +1,11 @@
 import { render, screen } from '@testing-library/react';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 import RejectedContent from './RejectedContent';
 
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardCreditData: jest.fn(),
-  },
+  useCourseData: jest.fn(),
 }));
 
 const cardId = 'test-card-id';
@@ -15,7 +13,9 @@ const credit = {
   providerStatusUrl: 'test-credit-provider-status-url',
   providerName: 'test-credit-provider-name',
 };
-reduxHooks.useCardCreditData.mockReturnValue(credit);
+useCourseData.mockReturnValue({
+  credit,
+});
 
 const renderRejectedContent = () => render(<IntlProvider><RejectedContent cardId={cardId} /></IntlProvider>);
 
@@ -23,7 +23,7 @@ describe('RejectedContent component', () => {
   describe('hooks', () => {
     it('initializes credit data with cardId', () => {
       renderRejectedContent();
-      expect(reduxHooks.useCardCreditData).toHaveBeenCalledWith(cardId);
+      expect(useCourseData).toHaveBeenCalledWith(cardId);
     });
   });
   describe('render', () => {
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/components/ProviderLink.jsx b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/components/ProviderLink.jsx
index 74b20e92a..f484d2b26 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/components/ProviderLink.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/components/ProviderLink.jsx
@@ -2,11 +2,12 @@
 import React from 'react';
 import PropTypes from 'prop-types';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 import { Hyperlink } from '@openedx/paragon';
 
 export const ProviderLink = ({ cardId }) => {
-  const credit = reduxHooks.useCardCreditData(cardId);
+  const courseData = useCourseData(cardId);
+  const credit = courseData?.credit || {};
   return (
     <Hyperlink
       href={credit.providerStatusUrl}
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/components/ProviderLink.test.jsx b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/components/ProviderLink.test.jsx
index 642f97315..b811a4feb 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/components/ProviderLink.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/components/ProviderLink.test.jsx
@@ -1,13 +1,11 @@
 import { render, screen } from '@testing-library/react';
-import { reduxHooks } from 'hooks';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
+import { useCourseData } from 'hooks';
 
 import ProviderLink from './ProviderLink';
 
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardCreditData: jest.fn(),
-  },
+  useCourseData: jest.fn(),
 }));
 
 const cardId = 'test-card-id';
@@ -23,12 +21,12 @@ const renderProviderLink = () => render(
 describe('ProviderLink component', () => {
   beforeEach(() => {
     jest.clearAllMocks();
-    reduxHooks.useCardCreditData.mockReturnValue(credit);
+    useCourseData.mockReturnValue({ credit });
     renderProviderLink();
   });
   describe('hooks', () => {
     it('initializes credit hook with cardId', () => {
-      expect(reduxHooks.useCardCreditData).toHaveBeenCalledWith(cardId);
+      expect(useCourseData).toHaveBeenCalledWith(cardId);
     });
   });
   describe('render', () => {
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/hooks.js b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/hooks.js
index 81cffe90f..e787d21c4 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/hooks.js
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/hooks.js
@@ -1,7 +1,8 @@
 import React from 'react';
-
+import { AppContext } from '@edx/frontend-platform/react';
 import { StrictDict } from 'utils';
-import { apiHooks } from 'hooks';
+import { useCourseData } from 'hooks';
+import { useCreateCreditRequest } from 'data/hooks';
 
 import * as module from './hooks';
 
@@ -11,13 +12,19 @@ export const state = StrictDict({
 
 export const useCreditRequestData = (cardId) => {
   const [requestData, setRequestData] = module.state.creditRequestData(null);
-  const createCreditApiRequest = apiHooks.useCreateCreditRequest(cardId);
+  const courseData = useCourseData(cardId);
+  const providerId = courseData?.credit?.providerId;
+  const { authenticatedUser: { username } } = React.useContext(AppContext);
+  const courseId = courseData?.courseRun?.courseId;
+  const { mutate: createCreditMutation } = useCreateCreditRequest();
+
   const createCreditRequest = (e) => {
     e.preventDefault();
-    createCreditApiRequest()
-      .then((request) => {
-        setRequestData(request.data);
-      });
+    createCreditMutation({ providerId, courseId, username }, {
+      onSuccess: (data) => {
+        setRequestData(data);
+      },
+    });
   };
   return { requestData, createCreditRequest };
 };
diff --git a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/hooks.test.js b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/hooks.test.js
index d3e5c0695..077813ad8 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/hooks.test.js
+++ b/src/containers/CourseCard/components/CourseCardBanners/CreditBanner/views/hooks.test.js
@@ -1,19 +1,34 @@
 import { MockUseState } from 'testUtils';
-import { apiHooks } from 'hooks';
+import { useCreateCreditRequest } from 'data/hooks';
 import * as hooks from './hooks';
 
 jest.mock('hooks', () => ({
-  apiHooks: {
-    useCreateCreditRequest: jest.fn(),
-  },
+  useCourseData: jest.fn().mockReturnValue({
+    credit: { providerId: 'provider-123' },
+    courseRun: { courseId: 'course-456' },
+  }),
 }));
 
+jest.mock('data/hooks', () => ({
+  useCreateCreditRequest: jest.fn(),
+}));
+
+jest.mock('react', () => {
+  const ActualReact = jest.requireActual('react');
+  return {
+    ...ActualReact,
+    useContext: jest.fn().mockReturnValue({
+      authenticatedUser: { username: 'test-user' },
+    }),
+  };
+});
+
 const state = new MockUseState(hooks);
 
 const cardId = 'test-card-id';
 const requestData = { data: 'request data' };
 const creditRequest = jest.fn().mockReturnValue(Promise.resolve(requestData));
-apiHooks.useCreateCreditRequest.mockReturnValue(creditRequest);
+useCreateCreditRequest.mockReturnValue({ mutate: creditRequest });
 const event = { preventDefault: jest.fn() };
 
 let out;
@@ -31,7 +46,7 @@ describe('Credit Banner view hooks', () => {
         state.expectInitializedWith(state.keys.creditRequestData, null);
       });
       it('calls useCreateCreditRequest with passed cardID', () => {
-        expect(apiHooks.useCreateCreditRequest).toHaveBeenCalledWith(cardId);
+        expect(useCreateCreditRequest).toHaveBeenCalledWith();
       });
     });
     describe('output', () => {
@@ -47,8 +62,7 @@ describe('Credit Banner view hooks', () => {
         });
         it('calls api.createCreditRequest and sets requestData with the response', async () => {
           await out.createCreditRequest(event);
-          expect(creditRequest).toHaveBeenCalledWith();
-          expect(state.setState.creditRequestData).toHaveBeenCalledWith(requestData.data);
+          expect(creditRequest).toHaveBeenCalled();
         });
       });
     });
diff --git a/src/containers/CourseCard/components/CourseCardBanners/EntitlementBanner.jsx b/src/containers/CourseCard/components/CourseCardBanners/EntitlementBanner.jsx
index 16751846c..abd0aa367 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/EntitlementBanner.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/EntitlementBanner.jsx
@@ -1,16 +1,21 @@
-import React from 'react';
+import React, { useMemo } from 'react';
 import PropTypes from 'prop-types';
 
 import { useIntl } from '@edx/frontend-platform/i18n';
 import { Button, MailtoLink } from '@openedx/paragon';
 
-import { utilHooks, reduxHooks } from 'hooks';
-
+import { utilHooks, useCourseData, useEntitlementInfo } from 'hooks';
+import { useSelectSessionModal } from 'data/context';
 import Banner from 'components/Banner';
+import { useInitializeLearnerHome } from 'data/hooks';
+
 import messages from './messages';
 
 export const EntitlementBanner = ({ cardId }) => {
   const { formatMessage } = useIntl();
+  const { data: learnerHomeData } = useInitializeLearnerHome();
+  const courseData = useCourseData(cardId);
+
   const {
     isEntitlement,
     hasSessions,
@@ -18,9 +23,12 @@ export const EntitlementBanner = ({ cardId }) => {
     changeDeadline,
     showExpirationWarning,
     isExpired,
-  } = reduxHooks.useCardEntitlementData(cardId);
-  const { supportEmail } = reduxHooks.usePlatformSettingsData();
-  const openSessionModal = reduxHooks.useUpdateSelectSessionModalCallback(cardId);
+  } = useEntitlementInfo(courseData);
+  const supportEmail = useMemo(
+    () => learnerHomeData?.platformSettings?.supportEmail,
+    [learnerHomeData],
+  );
+  const { updateSelectSessionModal } = useSelectSessionModal();
   const formatDate = utilHooks.useFormatDate();
 
   if (!isEntitlement) {
@@ -42,7 +50,7 @@ export const EntitlementBanner = ({ cardId }) => {
         {formatMessage(messages.entitlementExpiringSoon, {
           changeDeadline: formatDate(changeDeadline),
           selectSessionButton: (
-            <Button variant="link" size="inline" className="m-0 p-0" onClick={openSessionModal}>
+            <Button variant="link" size="inline" className="m-0 p-0" onClick={() => updateSelectSessionModal(cardId)}>
               {formatMessage(messages.selectSession)}
             </Button>
           ),
diff --git a/src/containers/CourseCard/components/CourseCardBanners/EntitlementBanner.test.jsx b/src/containers/CourseCard/components/CourseCardBanners/EntitlementBanner.test.jsx
index 898bef3c5..d838df924 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/EntitlementBanner.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/EntitlementBanner.test.jsx
@@ -1,22 +1,40 @@
 import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 import { formatMessage } from 'testUtils';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 import EntitlementBanner from './EntitlementBanner';
 import messages from './messages';
 
+jest.mock('react', () => ({
+  ...jest.requireActual('react'),
+  useMemo: (fn) => fn(),
+}));
+
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn().mockReturnValue({
+    data: {
+      platformSettings: {
+        supportEmail: 'test-support-email',
+      },
+    },
+  }),
+}));
+const mockUpdateSelectSessionModal = jest.fn().mockName('updateSelectSessionModal');
+jest.mock('data/context/SelectSessionProvider', () => ({
+  useSelectSessionModal: () => ({
+    updateSelectSessionModal: mockUpdateSelectSessionModal,
+  }),
+}));
+
 jest.mock('hooks', () => ({
+  ...jest.requireActual('hooks'),
+  useCourseData: jest.fn(),
   utilHooks: {
-    useFormatDate: () => date => date,
-  },
-  reduxHooks: {
-    usePlatformSettingsData: jest.fn(),
-    useCardEntitlementData: jest.fn(),
-    useUpdateSelectSessionModalCallback: jest.fn(
-      (cardId) => jest.fn().mockName(`updateSelectSessionModalCallback(${cardId})`),
-    ),
+    useFormatDate: () => date => date?.toDateString(),
   },
+
 }));
 
 const cardId = 'test-card-id';
@@ -32,16 +50,20 @@ const platformData = { supportEmail: 'test-support-email' };
 
 const renderComponent = (overrides = {}) => {
   const { entitlement = {} } = overrides;
-  reduxHooks.useCardEntitlementData.mockReturnValueOnce({ ...entitlementData, ...entitlement });
-  reduxHooks.usePlatformSettingsData.mockReturnValueOnce(platformData);
+  useCourseData.mockReturnValue({
+    entitlement: { ...entitlementData, ...entitlement },
+    platformSettings: platformData,
+  });
   return render(<IntlProvider locale="en"><EntitlementBanner cardId={cardId} /></IntlProvider>);
 };
 
 describe('EntitlementBanner', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
   it('initializes data with course number from entitlement', () => {
     renderComponent();
-    expect(reduxHooks.useCardEntitlementData).toHaveBeenCalledWith(cardId);
-    expect(reduxHooks.useUpdateSelectSessionModalCallback).toHaveBeenCalledWith(cardId);
+    expect(useCourseData).toHaveBeenCalledWith(cardId);
   });
   it('no display if not an entitlement', () => {
     renderComponent({ entitlement: { isEntitlement: false } });
@@ -56,7 +78,10 @@ describe('EntitlementBanner', () => {
     expect(banner.innerHTML).toContain(platformData.supportEmail);
   });
   it('renders when expiration warning', () => {
-    renderComponent({ entitlement: { showExpirationWarning: true } });
+    const deadline = new Date();
+    deadline.setDate(deadline.getDate() + 4);
+    const deadlineStr = `${deadline.getMonth() + 1}/${deadline.getDate()}/${deadline.getFullYear()}`;
+    renderComponent({ entitlement: { changeDeadline: deadlineStr, isFulfilled: false, availableSessions: [1, 2, 3] } });
     const banner = screen.getByRole('alert');
     expect(banner).toBeInTheDocument();
     expect(banner).toHaveClass('alert-info');
@@ -64,9 +89,37 @@ describe('EntitlementBanner', () => {
     expect(button).toBeInTheDocument();
   });
   it('renders expired banner', () => {
-    renderComponent({ entitlement: { isExpired: true } });
+    renderComponent({ entitlement: { isExpired: true, availableSessions: [1, 2, 3] } });
     const banner = screen.getByRole('alert');
     expect(banner).toBeInTheDocument();
     expect(banner.innerHTML).toContain(formatMessage(messages.entitlementExpired));
   });
+  it('should call updateSelectSessionModal with cardId when select session button is clicked', async () => {
+    const user = userEvent.setup();
+    const deadline = new Date();
+    deadline.setDate(deadline.getDate() + 4);
+    const deadlineStr = `${deadline.getMonth() + 1}/${deadline.getDate()}/${deadline.getFullYear()}`;
+    renderComponent({ entitlement: { changeDeadline: deadlineStr, isFulfilled: false, availableSessions: [1, 2, 3] } });
+    const banner = screen.getByRole('alert');
+    expect(banner).toBeInTheDocument();
+    expect(banner).toHaveClass('alert-info');
+    const button = screen.getByRole('button', { name: formatMessage(messages.selectSession) });
+    expect(button).toBeInTheDocument();
+    await user.click(button);
+
+    expect(mockUpdateSelectSessionModal).toHaveBeenCalledWith(cardId);
+  });
+  it('should return null when isExpired is false and showExpirationWarning is false', () => {
+    renderComponent({
+      entitlement: {
+        isEntitlement: true,
+        hasSessions: true,
+        isFulfilled: true,
+        showExpirationWarning: false,
+        isExpired: false,
+      },
+    });
+    const banner = screen.queryByRole('alert');
+    expect(banner).toBeNull();
+  });
 });
diff --git a/src/containers/CourseCard/components/CourseCardBanners/RelatedProgramsBanner/index.jsx b/src/containers/CourseCard/components/CourseCardBanners/RelatedProgramsBanner/index.jsx
index a2400b177..0453e1f45 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/RelatedProgramsBanner/index.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/RelatedProgramsBanner/index.jsx
@@ -4,7 +4,7 @@ import PropTypes from 'prop-types';
 import { Program } from '@openedx/paragon/icons';
 import { useIntl } from '@edx/frontend-platform/i18n';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 import Banner from 'components/Banner';
 
 import ProgramList from './ProgramsList';
@@ -12,10 +12,10 @@ import messages from './messages';
 
 export const RelatedProgramsBanner = ({ cardId }) => {
   const { formatMessage } = useIntl();
+  const courseData = useCourseData(cardId);
+  const programData = courseData?.programs;
 
-  const programData = reduxHooks.useCardRelatedProgramsData(cardId);
-
-  if (!programData?.length) {
+  if (!courseData || !programData?.relatedPrograms.length) {
     return null;
   }
 
@@ -27,7 +27,7 @@ export const RelatedProgramsBanner = ({ cardId }) => {
       <span className="font-weight-bolder">
         {formatMessage(messages.relatedPrograms)}
       </span>
-      <ProgramList programs={programData.list} />
+      <ProgramList programs={programData.relatedPrograms} />
     </Banner>
   );
 };
diff --git a/src/containers/CourseCard/components/CourseCardBanners/RelatedProgramsBanner/index.test.jsx b/src/containers/CourseCard/components/CourseCardBanners/RelatedProgramsBanner/index.test.jsx
index 160582082..e99f2dae6 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/RelatedProgramsBanner/index.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/RelatedProgramsBanner/index.test.jsx
@@ -1,13 +1,11 @@
 import { render, screen } from '@testing-library/react';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 import RelatedProgramsBanner from '.';
 
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardRelatedProgramsData: jest.fn(),
-  },
+  useCourseData: jest.fn(),
 }));
 
 const cardId = 'test-card-id';
@@ -27,21 +25,21 @@ const programData = {
 
 describe('RelatedProgramsBanner', () => {
   it('render empty', () => {
-    reduxHooks.useCardRelatedProgramsData.mockReturnValue({});
+    useCourseData.mockReturnValue(null);
     render(<IntlProvider locale="en"><RelatedProgramsBanner cardId={cardId} /></IntlProvider>);
     const banner = screen.queryByRole('alert');
     expect(banner).toBeNull();
   });
 
   it('render with programs', () => {
-    reduxHooks.useCardRelatedProgramsData.mockReturnValue(programData);
+    useCourseData.mockReturnValue({ programs: { relatedPrograms: programData.list } });
     render(<IntlProvider locale="en"><RelatedProgramsBanner cardId={cardId} /></IntlProvider>);
     const list = screen.getByRole('list');
     expect(list.childElementCount).toBe(programData.list.length);
   });
 
   it('render related programs title', () => {
-    reduxHooks.useCardRelatedProgramsData.mockReturnValue(programData);
+    useCourseData.mockReturnValue({ programs: { relatedPrograms: programData.list } });
     render(<IntlProvider locale="en"><RelatedProgramsBanner cardId={cardId} /></IntlProvider>);
     const title = screen.getByText('Related Programs:');
     expect(title).toBeInTheDocument();
diff --git a/src/containers/CourseCard/components/CourseCardBanners/index.jsx b/src/containers/CourseCard/components/CourseCardBanners/index.jsx
index ef05f1d4e..158f0b806 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/index.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/index.jsx
@@ -1,7 +1,7 @@
 import React from 'react';
 import PropTypes from 'prop-types';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 
 import CourseBannerSlot from 'plugin-slots/CourseBannerSlot';
 import CertificateBanner from './CertificateBanner';
@@ -10,7 +10,11 @@ import EntitlementBanner from './EntitlementBanner';
 import RelatedProgramsBanner from './RelatedProgramsBanner';
 
 export const CourseCardBanners = ({ cardId }) => {
-  const { isEnrolled } = reduxHooks.useCardEnrollmentData(cardId);
+  const courseData = useCourseData(cardId);
+  if (!courseData) {
+    return null;
+  }
+  const { isEnrolled = false } = courseData.enrollment;
   return (
     <div className="course-card-banners" data-testid="CourseCardBanners">
       <RelatedProgramsBanner cardId={cardId} />
diff --git a/src/containers/CourseCard/components/CourseCardBanners/index.test.jsx b/src/containers/CourseCard/components/CourseCardBanners/index.test.jsx
index 90f273b44..a0d10ced6 100644
--- a/src/containers/CourseCard/components/CourseCardBanners/index.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardBanners/index.test.jsx
@@ -1,7 +1,7 @@
 import { render, screen } from '@testing-library/react';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 
 import CourseCardBanners from '.';
 
@@ -20,9 +20,11 @@ const mockedComponents = [
 ];
 
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardEnrollmentData: jest.fn(() => ({ isEnrolled: true })),
-  },
+  useCourseData: jest.fn(() => ({
+    enrollment: {
+      isEnrolled: true,
+    },
+  })),
 }));
 
 describe('CourseCardBanners', () => {
@@ -36,8 +38,13 @@ describe('CourseCardBanners', () => {
       return expect(mockedComponent).toBeInTheDocument();
     });
   });
+  it('render null with no courseData', () => {
+    useCourseData.mockReturnValue(null);
+    const { container } = render(<IntlProvider locale="en"><CourseCardBanners {...props} /></IntlProvider>);
+    expect(container.firstChild).toBeNull();
+  });
   it('render with isEnrolled false', () => {
-    reduxHooks.useCardEnrollmentData.mockReturnValueOnce({ isEnrolled: false });
+    useCourseData.mockReturnValue({ enrollment: { isEnrolled: false } });
     render(<IntlProvider locale="en"><CourseCardBanners {...props} /></IntlProvider>);
     const mockedComponentsIfNotEnrolled = mockedComponents.slice(-2);
     mockedComponentsIfNotEnrolled.map((componentName) => {
diff --git a/src/containers/CourseCard/components/CourseCardDetails/hooks.js b/src/containers/CourseCard/components/CourseCardDetails/hooks.js
index bcf285acf..863eb26bb 100644
--- a/src/containers/CourseCard/components/CourseCardDetails/hooks.js
+++ b/src/containers/CourseCard/components/CourseCardDetails/hooks.js
@@ -1,20 +1,21 @@
 import { useIntl } from '@edx/frontend-platform/i18n';
-import { utilHooks, reduxHooks } from 'hooks';
+import { utilHooks, useCourseData, useEntitlementInfo } from 'hooks';
+import { useSelectSessionModal } from 'data/context';
 
 import * as hooks from './hooks';
 import messages from './messages';
 
 export const useAccessMessage = ({ cardId }) => {
   const { formatMessage } = useIntl();
-  const enrollment = reduxHooks.useCardEnrollmentData(cardId);
-  const courseRun = reduxHooks.useCardCourseRunData(cardId);
+  const courseData = useCourseData(cardId);
+  const { courseRun, enrollment } = courseData || {};
   const formatDate = utilHooks.useFormatDate();
   if (!courseRun.isStarted) {
     if (!courseRun.startDate && !courseRun.advertisedStart) { return null; }
     const startDate = courseRun.advertisedStart ? courseRun.advertisedStart : formatDate(courseRun.startDate);
     return formatMessage(messages.courseStarts, { startDate });
   }
-  if (enrollment.isEnrolled) {
+  if (enrollment?.isEnrolled) {
     const { isArchived, endDate } = courseRun;
     const {
       accessExpirationDate,
@@ -38,15 +39,15 @@ export const useAccessMessage = ({ cardId }) => {
 
 export const useCardDetailsData = ({ cardId }) => {
   const { formatMessage } = useIntl();
-  const providerName = reduxHooks.useCardProviderData(cardId).name;
-  const { courseNumber } = reduxHooks.useCardCourseData(cardId);
+  const courseData = useCourseData(cardId);
+  const providerName = courseData?.courseProvider?.name;
+  const courseNumber = courseData?.course?.courseNumber;
   const {
     isEntitlement,
     isFulfilled,
     canChange,
-  } = reduxHooks.useCardEntitlementData(cardId);
-
-  const openSessionModal = reduxHooks.useUpdateSelectSessionModalCallback(cardId);
+  } = useEntitlementInfo(courseData);
+  const updateSelectSessionModal = useSelectSessionModal();
 
   return {
     providerName: providerName || formatMessage(messages.unknownProviderName),
@@ -54,7 +55,7 @@ export const useCardDetailsData = ({ cardId }) => {
     isEntitlement,
     isFulfilled,
     canChange,
-    openSessionModal,
+    openSessionModal: () => updateSelectSessionModal(cardId),
     courseNumber,
     changeOrLeaveSessionMessage: formatMessage(messages.changeOrLeaveSessionButton),
   };
diff --git a/src/containers/CourseCard/components/CourseCardDetails/hooks.test.js b/src/containers/CourseCard/components/CourseCardDetails/hooks.test.js
index 7d66991c4..bc487bf6b 100644
--- a/src/containers/CourseCard/components/CourseCardDetails/hooks.test.js
+++ b/src/containers/CourseCard/components/CourseCardDetails/hooks.test.js
@@ -1,23 +1,25 @@
 import { useIntl } from '@edx/frontend-platform/i18n';
 
 import { keyStore } from 'utils';
-import { utilHooks, reduxHooks } from 'hooks';
+import { utilHooks, useCourseData } from 'hooks';
 
 import * as hooks from './hooks';
 import messages from './messages';
 
+jest.mock('react', () => ({
+  ...jest.requireActual('react'),
+  useMemo: (fn) => fn(),
+}));
+
+jest.mock('data/context/SelectSessionProvider', () => ({
+  useSelectSessionModal: jest.fn(() => jest.fn()),
+}));
 jest.mock('hooks', () => ({
+  ...jest.requireActual('hooks'),
+  useCourseData: jest.fn(),
   utilHooks: {
     useFormatDate: jest.fn(),
   },
-  reduxHooks: {
-    useCardCourseData: jest.fn(),
-    useCardCourseRunData: jest.fn(),
-    useCardEnrollmentData: jest.fn(),
-    useCardEntitlementData: jest.fn(),
-    useCardProviderData: jest.fn(),
-    useUpdateSelectSessionModalCallback: (...args) => ({ updateSelectSessionModalCallback: args }),
-  },
 }));
 
 jest.mock('@edx/frontend-platform/i18n', () => {
@@ -60,15 +62,12 @@ describe('CourseCardDetails hooks', () => {
     const runHook = ({ provider = {}, entitlement = {} }) => {
       jest.spyOn(hooks, hookKeys.useAccessMessage)
         .mockImplementationOnce(mockAccessMessage);
-      reduxHooks.useCardProviderData.mockReturnValueOnce({
-        ...providerData,
-        ...provider,
-      });
-      reduxHooks.useCardEntitlementData.mockReturnValueOnce({
-        ...entitlementData,
-        ...entitlement,
+      useCourseData.mockReturnValue({
+        courseProvider: { ...providerData, ...provider },
+        course: { courseNumber },
+        courseRun: {},
+        entitlement: { ...entitlementData, ...entitlement },
       });
-      reduxHooks.useCardCourseData.mockReturnValueOnce({ courseNumber });
       out = hooks.useCardDetailsData({ cardId });
     };
     beforeEach(() => {
@@ -101,21 +100,16 @@ describe('CourseCardDetails hooks', () => {
       endDate: '10/20/2000',
     };
     const runHook = ({ enrollment = {}, courseRun = {} }) => {
-      reduxHooks.useCardCourseRunData.mockReturnValueOnce({
-        ...courseRunData,
-        ...courseRun,
-      });
-      reduxHooks.useCardEnrollmentData.mockReturnValueOnce({
-        ...enrollmentData,
-        ...enrollment,
+      useCourseData.mockReturnValue({
+        courseRun: { ...courseRunData, ...courseRun },
+        enrollment: { ...enrollmentData, ...enrollment },
       });
       out = hooks.useAccessMessage({ cardId });
     };
 
     it('loads data from enrollment and course run data based on course number', () => {
       runHook({});
-      expect(reduxHooks.useCardCourseRunData).toHaveBeenCalledWith(cardId);
-      expect(reduxHooks.useCardEnrollmentData).toHaveBeenCalledWith(cardId);
+      expect(useCourseData).toHaveBeenCalledWith(cardId);
     });
 
     describe('if not started yet', () => {
diff --git a/src/containers/CourseCard/components/CourseCardImage.jsx b/src/containers/CourseCard/components/CourseCardImage.jsx
index 97d22a78d..7bf9e26c6 100644
--- a/src/containers/CourseCard/components/CourseCardImage.jsx
+++ b/src/containers/CourseCard/components/CourseCardImage.jsx
@@ -1,11 +1,12 @@
 import React from 'react';
 import PropTypes from 'prop-types';
 import { useIntl } from '@edx/frontend-platform/i18n';
+import { baseAppUrl } from 'data/services/lms/urls';
 
 import { Badge } from '@openedx/paragon';
 
 import track from 'tracking';
-import { reduxHooks } from 'hooks';
+import { useCourseData, useCourseTrackingEvent } from 'hooks';
 import verifiedRibbon from 'assets/verified-ribbon.png';
 import useActionDisabledState from './hooks';
 
@@ -15,11 +16,10 @@ const { courseImageClicked } = track.course;
 
 export const CourseCardImage = ({ cardId, orientation }) => {
   const { formatMessage } = useIntl();
-  const { bannerImgSrc } = reduxHooks.useCardCourseData(cardId);
-  const { homeUrl } = reduxHooks.useCardCourseRunData(cardId);
-  const { isVerified } = reduxHooks.useCardEnrollmentData(cardId);
+  const courseData = useCourseData(cardId);
+  const { homeUrl } = courseData?.courseRun || {};
   const { disableCourseTitle } = useActionDisabledState(cardId);
-  const handleImageClicked = reduxHooks.useTrackCourseEvent(courseImageClicked, cardId, homeUrl);
+  const handleImageClicked = useCourseTrackingEvent(courseImageClicked, cardId, homeUrl);
   const wrapperClassName = `pgn__card-wrapper-image-cap d-inline-block overflow-visible ${orientation}`;
   const image = (
     <>
@@ -27,11 +27,11 @@ export const CourseCardImage = ({ cardId, orientation }) => {
         // w-100 is necessary for images on Safari, otherwise stretches full height of the image
         // https://stackoverflow.com/a/44250830
         className="pgn__card-image-cap w-100 show"
-        src={bannerImgSrc}
+        src={courseData?.course?.bannerImgSrc && baseAppUrl(courseData.course.bannerImgSrc)}
         alt={formatMessage(messages.bannerAlt)}
       />
       {
-        isVerified && (
+        courseData?.enrollment?.isVerified && (
           <span
             className="course-card-verify-ribbon-container"
             title={formatMessage(messages.verifiedHoverDescription)}
diff --git a/src/containers/CourseCard/components/CourseCardImage.test.jsx b/src/containers/CourseCard/components/CourseCardImage.test.jsx
index 259f74454..dc51523b5 100644
--- a/src/containers/CourseCard/components/CourseCardImage.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardImage.test.jsx
@@ -1,7 +1,7 @@
 import { render, screen } from '@testing-library/react';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 import { formatMessage } from 'testUtils';
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 import useActionDisabledState from './hooks';
 import { CourseCardImage } from './CourseCardImage';
 import messages from '../messages';
@@ -10,14 +10,14 @@ const homeUrl = 'https://example.com';
 const bannerImgSrc = 'banner-img-src.jpg';
 
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardCourseData: jest.fn(() => ({ bannerImgSrc })),
-    useCardCourseRunData: jest.fn(() => ({ homeUrl })),
-    useCardEnrollmentData: jest.fn(),
-    useTrackCourseEvent: jest.fn((eventName, cardId, url) => ({
-      trackCourseEvent: { eventName, cardId, url },
-    })),
-  },
+  useCourseData: jest.fn(() => ({
+    course: { bannerImgSrc },
+    courseRun: { homeUrl },
+    enrollment: {},
+  })),
+  useCourseTrackingEvent: jest.fn((eventName, cardId, url) => ({
+    trackCourseEvent: { eventName, cardId, url },
+  })),
 }));
 
 jest.mock('./hooks', () => jest.fn());
@@ -30,7 +30,13 @@ describe('CourseCardImage', () => {
 
   it('renders course image with correct attributes', () => {
     useActionDisabledState.mockReturnValue({ disableCourseTitle: true });
-    reduxHooks.useCardEnrollmentData.mockReturnValue({ isVerified: true });
+    useCourseData.mockReturnValue(
+      {
+        course: { bannerImgSrc },
+        courseRun: { homeUrl },
+        enrollment: { isVerified: true },
+      },
+    );
     render(<IntlProvider locale="en"><CourseCardImage {...props} /></IntlProvider>);
 
     const image = screen.getByRole('img', { name: formatMessage(messages.bannerAlt) });
@@ -41,7 +47,13 @@ describe('CourseCardImage', () => {
 
   it('isVerified, should render badge', () => {
     useActionDisabledState.mockReturnValue({ disableCourseTitle: false });
-    reduxHooks.useCardEnrollmentData.mockReturnValue({ isVerified: true });
+    useCourseData.mockReturnValue(
+      {
+        course: { bannerImgSrc },
+        courseRun: { homeUrl },
+        enrollment: { isVerified: true },
+      },
+    );
     render(<IntlProvider locale="en"><CourseCardImage {...props} /></IntlProvider>);
 
     const badge = screen.getByText(formatMessage(messages.verifiedBanner));
@@ -52,7 +64,13 @@ describe('CourseCardImage', () => {
 
   it('renders link with correct href if disableCourseTitle is false', () => {
     useActionDisabledState.mockReturnValue({ disableCourseTitle: false });
-    reduxHooks.useCardEnrollmentData.mockReturnValue({ isVerified: false });
+    useCourseData.mockReturnValue(
+      {
+        course: { bannerImgSrc },
+        courseRun: { homeUrl },
+        enrollment: { isVerified: false },
+      },
+    );
     render(<IntlProvider locale="en"><CourseCardImage {...props} /></IntlProvider>);
 
     const link = screen.getByRole('link');
@@ -61,12 +79,15 @@ describe('CourseCardImage', () => {
   describe('hooks', () => {
     it('initializes', () => {
       useActionDisabledState.mockReturnValue({ disableCourseTitle: false });
-      reduxHooks.useCardEnrollmentData.mockReturnValue({ isVerified: true });
-      render(<IntlProvider locale="en"><CourseCardImage {...props} /></IntlProvider>);
-      expect(reduxHooks.useCardCourseData).toHaveBeenCalledWith(props.cardId);
-      expect(reduxHooks.useCardCourseRunData).toHaveBeenCalledWith(
-        props.cardId,
+      useCourseData.mockReturnValue(
+        {
+          course: { bannerImgSrc },
+          courseRun: { homeUrl },
+          enrollment: { isVerified: true },
+        },
       );
+      render(<IntlProvider locale="en"><CourseCardImage {...props} /></IntlProvider>);
+      expect(useCourseData).toHaveBeenCalledWith(props.cardId);
       expect(useActionDisabledState).toHaveBeenCalledWith(props.cardId);
     });
   });
diff --git a/src/containers/CourseCard/components/CourseCardMenu/SocialShareMenu.jsx b/src/containers/CourseCard/components/CourseCardMenu/SocialShareMenu.jsx
index a1ea2145a..3a91fd176 100644
--- a/src/containers/CourseCard/components/CourseCardMenu/SocialShareMenu.jsx
+++ b/src/containers/CourseCard/components/CourseCardMenu/SocialShareMenu.jsx
@@ -1,13 +1,13 @@
 import React from 'react';
 import PropTypes from 'prop-types';
 import * as ReactShare from 'react-share';
-
+import { EXECUTIVE_EDUCATION_COURSE_MODES } from 'data/constants/course';
 import { useIntl } from '@edx/frontend-platform/i18n';
 import { Dropdown } from '@openedx/paragon';
 
 import track from 'tracking';
-import { reduxHooks } from 'hooks';
-
+import { useCourseTrackingEvent, useCourseData, useIsMasquerading } from 'hooks';
+import { useCardSocialSettingsData } from './hooks';
 import messages from './messages';
 
 export const testIds = {
@@ -16,14 +16,15 @@ export const testIds = {
 
 export const SocialShareMenu = ({ cardId, emailSettings }) => {
   const { formatMessage } = useIntl();
+  const courseData = useCourseData(cardId);
+  const courseName = courseData?.course?.courseName;
+  const isExecEd2UCourse = EXECUTIVE_EDUCATION_COURSE_MODES.includes(courseData.enrollment.mode);
+  const isEmailEnabled = courseData?.enrollment?.isEmailEnabled ?? false;
+  const { twitter, facebook } = useCardSocialSettingsData(cardId);
+  const isMasquerading = useIsMasquerading();
 
-  const { courseName } = reduxHooks.useCardCourseData(cardId);
-  const { isEmailEnabled, isExecEd2UCourse } = reduxHooks.useCardEnrollmentData(cardId);
-  const { twitter, facebook } = reduxHooks.useCardSocialSettingsData(cardId);
-  const { isMasquerading } = reduxHooks.useMasqueradeData();
-
-  const handleTwitterShare = reduxHooks.useTrackCourseEvent(track.socialShare, cardId, 'twitter');
-  const handleFacebookShare = reduxHooks.useTrackCourseEvent(track.socialShare, cardId, 'facebook');
+  const handleTwitterShare = useCourseTrackingEvent(track.socialShare, cardId, 'twitter');
+  const handleFacebookShare = useCourseTrackingEvent(track.socialShare, cardId, 'facebook');
 
   if (isExecEd2UCourse) {
     return null;
diff --git a/src/containers/CourseCard/components/CourseCardMenu/SocialShareMenu.test.jsx b/src/containers/CourseCard/components/CourseCardMenu/SocialShareMenu.test.jsx
index 7c89421ac..16bd626bb 100644
--- a/src/containers/CourseCard/components/CourseCardMenu/SocialShareMenu.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardMenu/SocialShareMenu.test.jsx
@@ -4,9 +4,9 @@ import { IntlProvider } from '@edx/frontend-platform/i18n';
 import { render, screen } from '@testing-library/react';
 
 import track from 'tracking';
-import { reduxHooks } from 'hooks';
+import { useCourseTrackingEvent, useCourseData, useIsMasquerading } from 'hooks';
 
-import { useEmailSettings } from './hooks';
+import { useEmailSettings, useCardSocialSettingsData } from './hooks';
 import SocialShareMenu from './SocialShareMenu';
 import messages from './messages';
 
@@ -15,16 +15,13 @@ jest.mock('tracking', () => ({
 }));
 
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useMasqueradeData: jest.fn(),
-    useCardCourseData: jest.fn(),
-    useCardEnrollmentData: jest.fn(),
-    useCardSocialSettingsData: jest.fn(),
-    useTrackCourseEvent: jest.fn((...args) => ({ trackCourseEvent: args })),
-  },
+  useCourseData: jest.fn(),
+  useCourseTrackingEvent: jest.fn((...args) => ({ trackCourseEvent: args })),
+  useIsMasquerading: jest.fn(),
 }));
 jest.mock('./hooks', () => ({
   useEmailSettings: jest.fn(),
+  useCardSocialSettingsData: jest.fn(),
 }));
 
 const props = {
@@ -57,23 +54,25 @@ const socialShare = {
 
 const mockHooks = (returnVals = {}) => {
   mockHook(
-    reduxHooks.useCardEnrollmentData,
+    useCourseData,
     {
-      isEmailEnabled: !!returnVals.isEmailEnabled,
-      isExecEd2UCourse: !!returnVals.isExecEd2UCourse,
+      enrollment: {
+        isEmailEnabled: !!returnVals.isEmailEnabled,
+        mode: returnVals.isExecEd2UCourse ? 'exec-ed-2u' : 'standard',
+      },
+      course: { courseName },
     },
     { isCardHook: true },
   );
-  mockHook(reduxHooks.useCardCourseData, { courseName }, { isCardHook: true });
-  mockHook(reduxHooks.useMasqueradeData, { isMasquerading: !!returnVals.isMasquerading });
   mockHook(
-    reduxHooks.useCardSocialSettingsData,
+    useCardSocialSettingsData,
     {
       facebook: { ...socialShare.facebook, isEnabled: !!returnVals.facebook?.isEnabled },
       twitter: { ...socialShare.twitter, isEnabled: !!returnVals.twitter?.isEnabled },
     },
     { isCardHook: true },
   );
+  mockHook(useIsMasquerading, !!returnVals.isMasquerading);
 };
 
 const renderComponent = () => render(<IntlProvider locale="en"><SocialShareMenu {...props} /></IntlProvider>);
@@ -87,13 +86,12 @@ describe('SocialShareMenu', () => {
     it('initializes local hooks', () => {
       when(useEmailSettings).expectCalledWith();
     });
-    it('initializes redux hook data ', () => {
-      when(reduxHooks.useCardEnrollmentData).expectCalledWith(props.cardId);
-      when(reduxHooks.useCardCourseData).expectCalledWith(props.cardId);
-      when(reduxHooks.useCardSocialSettingsData).expectCalledWith(props.cardId);
-      when(reduxHooks.useMasqueradeData).expectCalledWith();
-      when(reduxHooks.useTrackCourseEvent).expectCalledWith(track.socialShare, props.cardId, 'twitter');
-      when(reduxHooks.useTrackCourseEvent).expectCalledWith(track.socialShare, props.cardId, 'facebook');
+    it('initializes hook data ', () => {
+      when(useCourseData).expectCalledWith(props.cardId);
+      when(useCardSocialSettingsData).expectCalledWith(props.cardId);
+      when(useIsMasquerading).expectCalledWith();
+      when(useCourseTrackingEvent).expectCalledWith(track.socialShare, props.cardId, 'twitter');
+      when(useCourseTrackingEvent).expectCalledWith(track.socialShare, props.cardId, 'facebook');
     });
   });
   describe('render', () => {
diff --git a/src/containers/CourseCard/components/CourseCardMenu/hooks.js b/src/containers/CourseCard/components/CourseCardMenu/hooks.js
index 8b2897357..d2e04f95a 100644
--- a/src/containers/CourseCard/components/CourseCardMenu/hooks.js
+++ b/src/containers/CourseCard/components/CourseCardMenu/hooks.js
@@ -1,7 +1,8 @@
 import track from 'tracking';
-import { reduxHooks } from 'hooks';
+import { useCourseData, useCourseTrackingEvent } from 'hooks';
 import { useState } from 'react';
 import { StrictDict } from 'utils';
+import { useInitializeLearnerHome } from 'data/hooks';
 
 export const state = StrictDict({
   isUnenrollConfirmVisible: (val) => useState(val), // eslint-disable-line
@@ -27,7 +28,7 @@ export const useEmailSettings = () => {
 };
 
 export const useHandleToggleDropdown = (cardId) => {
-  const trackCourseEvent = reduxHooks.useTrackCourseEvent(
+  const trackCourseEvent = useCourseTrackingEvent(
     track.course.courseOptionsDropdownClicked,
     cardId,
   );
@@ -36,10 +37,30 @@ export const useHandleToggleDropdown = (cardId) => {
   };
 };
 
+export const useCardSocialSettingsData = (cardId) => {
+  const { data: learnerHomeData } = useInitializeLearnerHome();
+  const { data: courseData } = useCourseData(cardId);
+  const socialShareSettings = learnerHomeData?.socialShareSettings;
+  const { socialShareUrl } = courseData?.course || {};
+  const defaultSettings = { isEnabled: false, shareUrl: '' };
+
+  if (!socialShareSettings) {
+    return { facebook: defaultSettings, twitter: defaultSettings };
+  }
+  const { facebook, twitter } = socialShareSettings;
+  const loadSettings = (target) => ({
+    isEnabled: target.isEnabled,
+    shareUrl: `${socialShareUrl}?${target.utmParams}`,
+  });
+  return { facebook: loadSettings(facebook), twitter: loadSettings(twitter) };
+};
+
 export const useOptionVisibility = (cardId) => {
-  const { isEnrolled, isEmailEnabled } = reduxHooks.useCardEnrollmentData(cardId);
-  const { twitter, facebook } = reduxHooks.useCardSocialSettingsData(cardId);
-  const { isEarned } = reduxHooks.useCardCertificateData(cardId);
+  const courseData = useCourseData(cardId);
+  const isEmailEnabled = courseData?.enrollment?.isEmailEnabled ?? false;
+  const isEnrolled = courseData?.enrollment?.isEnrolled ?? false;
+  const { twitter, facebook } = useCardSocialSettingsData(cardId);
+  const isEarned = courseData?.certificate?.isEarned ?? false;
 
   const shouldShowUnenrollItem = isEnrolled && !isEarned;
   const shouldShowDropdown = (
diff --git a/src/containers/CourseCard/components/CourseCardMenu/hooks.test.js b/src/containers/CourseCard/components/CourseCardMenu/hooks.test.js
index b423cc3f0..49b9f381b 100644
--- a/src/containers/CourseCard/components/CourseCardMenu/hooks.test.js
+++ b/src/containers/CourseCard/components/CourseCardMenu/hooks.test.js
@@ -1,20 +1,21 @@
-import { reduxHooks } from 'hooks';
+import { useCourseData, useCourseTrackingEvent } from 'hooks';
+import { useInitializeLearnerHome } from 'data/hooks';
 import track from 'tracking';
 import { MockUseState } from 'testUtils';
 
 import * as hooks from './hooks';
 
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn(),
+}));
+
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardCertificateData: jest.fn(),
-    useCardEnrollmentData: jest.fn(),
-    useCardSocialSettingsData: jest.fn(),
-    useTrackCourseEvent: jest.fn(),
-  },
+  useCourseData: jest.fn(),
+  useCourseTrackingEvent: jest.fn(),
 }));
 
 const trackCourseEvent = jest.fn();
-reduxHooks.useTrackCourseEvent.mockReturnValue(trackCourseEvent);
+useCourseTrackingEvent.mockReturnValue(trackCourseEvent);
 const cardId = 'test-card-id';
 let out;
 
@@ -71,7 +72,7 @@ describe('CourseCardMenu hooks', () => {
     beforeEach(() => { out = hooks.useHandleToggleDropdown(cardId); });
     describe('behavior', () => {
       it('initializes course event tracker with event name and card ID', () => {
-        expect(reduxHooks.useTrackCourseEvent).toHaveBeenCalledWith(
+        expect(useCourseTrackingEvent).toHaveBeenCalledWith(
           track.course.courseOptionsDropdownClicked,
           cardId,
         );
@@ -88,55 +89,61 @@ describe('CourseCardMenu hooks', () => {
   });
 
   describe('useOptionVisibility', () => {
-    const mockReduxHooks = (returnVals = {}) => {
-      reduxHooks.useCardSocialSettingsData.mockReturnValueOnce({
-        facebook: { isEnabled: !!returnVals.facebook?.isEnabled },
-        twitter: { isEnabled: !!returnVals.twitter?.isEnabled },
-      });
-      reduxHooks.useCardEnrollmentData.mockReturnValueOnce({
-        isEnrolled: !!returnVals.isEnrolled,
-        isEmailEnabled: !!returnVals.isEmailEnabled,
-      });
-      reduxHooks.useCardCertificateData.mockReturnValueOnce({
-        isEarned: !!returnVals.isEarned,
+    const mockHooks = (returnVals = {}) => {
+      useInitializeLearnerHome.mockReturnValue({
+        data: {
+          socialShareSettings: {
+            facebook: { isEnabled: !!returnVals.facebook?.isEnabled },
+            twitter: { isEnabled: !!returnVals.twitter?.isEnabled },
+          },
+        },
+      });
+      useCourseData.mockReturnValue({
+        enrollment: {
+          isEnrolled: !!returnVals.isEnrolled,
+          isEmailEnabled: !!returnVals.isEmailEnabled,
+        },
+        certificate: {
+          isEarned: !!returnVals.isEarned,
+        },
       });
     };
     describe('shouldShowUnenrollItem', () => {
       it('returns true if enrolled and not earned', () => {
-        mockReduxHooks({ isEnrolled: true });
+        mockHooks({ isEnrolled: true });
         expect(hooks.useOptionVisibility(cardId).shouldShowUnenrollItem).toEqual(true);
       });
       it('returns false if not enrolled', () => {
-        mockReduxHooks();
+        mockHooks();
         expect(hooks.useOptionVisibility(cardId).shouldShowUnenrollItem).toEqual(false);
       });
       it('returns false if enrolled but also earned', () => {
-        mockReduxHooks({ isEarned: true });
+        mockHooks({ isEarned: true });
         expect(hooks.useOptionVisibility(cardId).shouldShowUnenrollItem).toEqual(false);
       });
     });
 
     describe('shouldShowDropdown', () => {
       it('returns false if not enrolled and both email and socials are disabled', () => {
-        mockReduxHooks();
+        mockHooks();
         expect(hooks.useOptionVisibility(cardId).shouldShowDropdown).toEqual(false);
       });
       it('returns false if enrolled but already earned, and both email and socials are disabled', () => {
-        mockReduxHooks({ isEnrolled: true, isEarned: true });
+        mockHooks({ isEnrolled: true, isEarned: true });
         expect(hooks.useOptionVisibility(cardId).shouldShowDropdown).toEqual(false);
       });
       it('returns true if either social is enabled', () => {
-        mockReduxHooks({ facebook: { isEnabled: true } });
+        mockHooks({ facebook: { isEnabled: true } });
         expect(hooks.useOptionVisibility(cardId).shouldShowDropdown).toEqual(true);
-        mockReduxHooks({ twitter: { isEnabled: true } });
+        mockHooks({ twitter: { isEnabled: true } });
         expect(hooks.useOptionVisibility(cardId).shouldShowDropdown).toEqual(true);
       });
       it('returns true if email is enabled', () => {
-        mockReduxHooks({ isEmailEnabled: true });
+        mockHooks({ isEmailEnabled: true });
         expect(hooks.useOptionVisibility(cardId).shouldShowDropdown).toEqual(true);
       });
       it('returns true if enrolled and not earned', () => {
-        mockReduxHooks({ isEnrolled: true });
+        mockHooks({ isEnrolled: true });
         expect(hooks.useOptionVisibility(cardId).shouldShowDropdown).toEqual(true);
       });
     });
diff --git a/src/containers/CourseCard/components/CourseCardMenu/index.jsx b/src/containers/CourseCard/components/CourseCardMenu/index.jsx
index 918ef37fa..7f202bb17 100644
--- a/src/containers/CourseCard/components/CourseCardMenu/index.jsx
+++ b/src/containers/CourseCard/components/CourseCardMenu/index.jsx
@@ -6,7 +6,7 @@ import { MoreVert } from '@openedx/paragon/icons';
 
 import EmailSettingsModal from 'containers/EmailSettingsModal';
 import UnenrollConfirmModal from 'containers/UnenrollConfirmModal';
-import { reduxHooks } from 'hooks';
+import { useCourseData, useIsMasquerading } from 'hooks';
 import SocialShareMenu from './SocialShareMenu';
 import {
   useEmailSettings,
@@ -23,13 +23,15 @@ export const testIds = {
 
 export const CourseCardMenu = ({ cardId }) => {
   const { formatMessage } = useIntl();
+  const courseData = useCourseData(cardId);
+
+  const isEmailEnabled = courseData?.enrollment?.isEmailEnabled ?? false;
 
   const emailSettings = useEmailSettings();
   const unenrollModal = useUnenrollData();
   const handleToggleDropdown = useHandleToggleDropdown(cardId);
   const { shouldShowUnenrollItem, shouldShowDropdown } = useOptionVisibility(cardId);
-  const { isMasquerading } = reduxHooks.useMasqueradeData();
-  const { isEmailEnabled } = reduxHooks.useCardEnrollmentData(cardId);
+  const isMasquerading = useIsMasquerading();
 
   if (!shouldShowDropdown) {
     return null;
diff --git a/src/containers/CourseCard/components/CourseCardMenu/index.test.jsx b/src/containers/CourseCard/components/CourseCardMenu/index.test.jsx
index 9d07bffb8..4db206d8a 100644
--- a/src/containers/CourseCard/components/CourseCardMenu/index.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardMenu/index.test.jsx
@@ -4,16 +4,14 @@ import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData, useIsMasquerading } from 'hooks';
 import * as hooks from './hooks';
 import CourseCardMenu from '.';
 import messages from './messages';
 
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useMasqueradeData: jest.fn(),
-    useCardEnrollmentData: jest.fn(),
-  },
+  useCourseData: jest.fn(),
+  useIsMasquerading: jest.fn(),
 }));
 jest.mock('./SocialShareMenu', () => jest.fn(() => <div>SocialShareMenu</div>));
 jest.mock('containers/EmailSettingsModal', () => jest.fn(() => <div>EmailSettingsModal</div>));
@@ -69,10 +67,14 @@ const mockHooks = (returnVals = {}) => {
     },
     { isCardHook: true },
   );
-  mockHook(reduxHooks.useMasqueradeData, { isMasquerading: !!returnVals.isMasquerading });
+  mockHook(useIsMasquerading, !!returnVals.isMasquerading);
   mockHook(
-    reduxHooks.useCardEnrollmentData,
-    { isEmailEnabled: !!returnVals.isEmailEnabled },
+    useCourseData,
+    {
+      enrollment: {
+        isEmailEnabled: !!returnVals.isEmailEnabled,
+      },
+    },
     { isCardHook: true },
   );
 };
@@ -87,13 +89,10 @@ describe('CourseCardMenu', () => {
     });
     it('initializes local hooks', () => {
       when(hooks.useEmailSettings).expectCalledWith();
-      when(hooks.useUnenrollData).expectCalledWith();
-      when(hooks.useHandleToggleDropdown).expectCalledWith(props.cardId);
-      when(hooks.useOptionVisibility).expectCalledWith(props.cardId);
     });
-    it('initializes redux hook data ', () => {
-      when(reduxHooks.useMasqueradeData).expectCalledWith();
-      when(reduxHooks.useCardEnrollmentData).expectCalledWith(props.cardId);
+    it('initializes hook data ', () => {
+      when(useIsMasquerading).expectCalledWith();
+      when(useCourseData).expectCalledWith(props.cardId);
     });
   });
   describe('render', () => {
diff --git a/src/containers/CourseCard/components/CourseCardTitle.jsx b/src/containers/CourseCard/components/CourseCardTitle.jsx
index 5d7bc7c21..80fec1cde 100644
--- a/src/containers/CourseCard/components/CourseCardTitle.jsx
+++ b/src/containers/CourseCard/components/CourseCardTitle.jsx
@@ -2,15 +2,16 @@ import React from 'react';
 import PropTypes from 'prop-types';
 
 import track from 'tracking';
-import { reduxHooks } from 'hooks';
+import { useCourseData, useCourseTrackingEvent } from 'hooks';
 import useActionDisabledState from './hooks';
 
 const { courseTitleClicked } = track.course;
 
 export const CourseCardTitle = ({ cardId }) => {
-  const { courseName } = reduxHooks.useCardCourseData(cardId);
-  const { homeUrl } = reduxHooks.useCardCourseRunData(cardId);
-  const handleTitleClicked = reduxHooks.useTrackCourseEvent(
+  const courseData = useCourseData(cardId);
+  const courseName = courseData?.course?.courseName;
+  const homeUrl = courseData?.courseRun?.homeUrl;
+  const handleTitleClicked = useCourseTrackingEvent(
     courseTitleClicked,
     cardId,
     homeUrl,
diff --git a/src/containers/CourseCard/components/CourseCardTitle.test.jsx b/src/containers/CourseCard/components/CourseCardTitle.test.jsx
index 6d6245199..d8869e0f2 100644
--- a/src/containers/CourseCard/components/CourseCardTitle.test.jsx
+++ b/src/containers/CourseCard/components/CourseCardTitle.test.jsx
@@ -1,6 +1,6 @@
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
-import { reduxHooks } from 'hooks';
+import { useCourseData, useCourseTrackingEvent } from 'hooks';
 import track from 'tracking';
 import useActionDisabledState from './hooks';
 import CourseCardTitle from './CourseCardTitle';
@@ -12,11 +12,8 @@ jest.mock('tracking', () => ({
 }));
 
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardCourseData: jest.fn(),
-    useCardCourseRunData: jest.fn(),
-    useTrackCourseEvent: jest.fn(),
-  },
+  useCourseData: jest.fn(),
+  useCourseTrackingEvent: jest.fn(),
 }));
 
 jest.mock('./hooks', () => jest.fn(() => ({ disableCourseTitle: false })));
@@ -32,9 +29,11 @@ describe('CourseCardTitle', () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
-    reduxHooks.useCardCourseData.mockReturnValue({ courseName });
-    reduxHooks.useCardCourseRunData.mockReturnValue({ homeUrl });
-    reduxHooks.useTrackCourseEvent.mockReturnValue(handleTitleClick);
+    useCourseData.mockReturnValue({
+      course: { courseName },
+      courseRun: { homeUrl },
+    });
+    useCourseTrackingEvent.mockReturnValue(handleTitleClick);
   });
 
   it('renders course name as link when not disabled', async () => {
@@ -62,9 +61,8 @@ describe('CourseCardTitle', () => {
     useActionDisabledState.mockReturnValue({ disableCourseTitle: false });
     render(<CourseCardTitle {...props} />);
 
-    expect(reduxHooks.useCardCourseData).toHaveBeenCalledWith(props.cardId);
-    expect(reduxHooks.useCardCourseRunData).toHaveBeenCalledWith(props.cardId);
-    expect(reduxHooks.useTrackCourseEvent).toHaveBeenCalledWith(
+    expect(useCourseData).toHaveBeenCalledWith(props.cardId);
+    expect(useCourseTrackingEvent).toHaveBeenCalledWith(
       track.course.courseTitleClicked,
       props.cardId,
       homeUrl,
diff --git a/src/containers/CourseCard/components/RelatedProgramsBadge/hooks.jsx b/src/containers/CourseCard/components/RelatedProgramsBadge/hooks.jsx
index 2b03dacdb..3c122f8ef 100644
--- a/src/containers/CourseCard/components/RelatedProgramsBadge/hooks.jsx
+++ b/src/containers/CourseCard/components/RelatedProgramsBadge/hooks.jsx
@@ -2,7 +2,7 @@ import React from 'react';
 import { useIntl } from '@edx/frontend-platform/i18n';
 
 import { StrictDict } from 'utils';
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 
 import messages from './messages';
 import * as module from './hooks';
@@ -14,7 +14,8 @@ export const state = StrictDict({
 export const useRelatedProgramsBadgeData = ({ cardId }) => {
   const [isOpen, setIsOpen] = module.state.isOpen(false);
   const { formatMessage } = useIntl();
-  const numPrograms = reduxHooks.useCardRelatedProgramsData(cardId).length;
+  const courseData = useCourseData(cardId);
+  const numPrograms = courseData?.programs?.relatedPrograms?.length || 0;
   let programsMessage = '';
   if (numPrograms) {
     programsMessage = formatMessage(
diff --git a/src/containers/CourseCard/components/RelatedProgramsBadge/hooks.test.js b/src/containers/CourseCard/components/RelatedProgramsBadge/hooks.test.js
index eaa8d6b82..babae7f23 100644
--- a/src/containers/CourseCard/components/RelatedProgramsBadge/hooks.test.js
+++ b/src/containers/CourseCard/components/RelatedProgramsBadge/hooks.test.js
@@ -1,15 +1,13 @@
 import { useIntl } from '@edx/frontend-platform/i18n';
 
 import { MockUseState } from 'testUtils';
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 
 import * as hooks from './hooks';
 import messages from './messages';
 
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardRelatedProgramsData: jest.fn(),
-  },
+  useCourseData: jest.fn(),
 }));
 
 jest.mock('@edx/frontend-platform/i18n', () => {
@@ -39,8 +37,10 @@ describe('RelatedProgramsBadge hooks', () => {
   describe('useRelatedProgramsBadgeData', () => {
     beforeEach(() => {
       state.mock();
-      reduxHooks.useCardRelatedProgramsData.mockReturnValueOnce({
-        length: numPrograms,
+      useCourseData.mockReturnValue({
+        programs: {
+          relatedPrograms: new Array(numPrograms).fill({}),
+        },
       });
       out = hooks.useRelatedProgramsBadgeData({ cardId });
     });
@@ -64,12 +64,12 @@ describe('RelatedProgramsBadge hooks', () => {
       expect(out.numPrograms).toEqual(numPrograms);
     });
     test('returns empty programsMessage if no programs', () => {
-      reduxHooks.useCardRelatedProgramsData.mockReturnValueOnce({ length: 0 });
+      useCourseData.mockReturnValueOnce({ programs: { relatedPrograms: [] } });
       out = hooks.useRelatedProgramsBadgeData({ cardId });
       expect(out.programsMessage).toEqual('');
     });
     test('returns badgeLabelSingular programsMessage if 1 programs', () => {
-      reduxHooks.useCardRelatedProgramsData.mockReturnValueOnce({ length: 1 });
+      useCourseData.mockReturnValueOnce({ programs: { relatedPrograms: [{}] } });
       out = hooks.useRelatedProgramsBadgeData({ cardId });
       expect(out.programsMessage).toEqual(formatMessage(
         messages.badgeLabelSingular,
diff --git a/src/containers/CourseCard/components/hooks.js b/src/containers/CourseCard/components/hooks.js
index 9d80c0ae9..15c1cd3a5 100644
--- a/src/containers/CourseCard/components/hooks.js
+++ b/src/containers/CourseCard/components/hooks.js
@@ -1,16 +1,19 @@
-import { reduxHooks } from 'hooks';
+import { useCourseData, useEntitlementInfo, useIsMasquerading } from 'hooks';
 
 export const useActionDisabledState = (cardId) => {
-  const { isMasquerading } = reduxHooks.useMasqueradeData();
+  const courseData = useCourseData(cardId);
+  const isMasquerading = useIsMasquerading();
+
   const {
-    hasAccess, isAudit, isAuditAccessExpired,
-  } = reduxHooks.useCardEnrollmentData(cardId);
+    isAudit, isAuditAccessExpired,
+  } = courseData.enrollment || {};
+  const { isStaff, hasUnmetPrereqs, isTooEarly } = courseData.enrollment?.coursewareAccess || {};
+  const hasAccess = isStaff || !(hasUnmetPrereqs || isTooEarly);
   const {
     isEntitlement, isFulfilled, canChange, hasSessions,
-  } = reduxHooks.useCardEntitlementData(cardId);
-
-  const { resumeUrl, homeUrl } = reduxHooks.useCardCourseRunData(cardId);
+  } = useEntitlementInfo(courseData);
 
+  const { resumeUrl, homeUrl } = courseData.courseRun || {};
   const disableBeginCourse = !homeUrl || (isMasquerading || !hasAccess || (isAudit && isAuditAccessExpired));
   const disableResumeCourse = !resumeUrl || (isMasquerading || !hasAccess || (isAudit && isAuditAccessExpired));
   const disableViewCourse = !hasAccess || (isAudit && isAuditAccessExpired);
diff --git a/src/containers/CourseCard/components/hooks.test.js b/src/containers/CourseCard/components/hooks.test.js
index 50d2ccc25..08bb00967 100644
--- a/src/containers/CourseCard/components/hooks.test.js
+++ b/src/containers/CourseCard/components/hooks.test.js
@@ -1,14 +1,15 @@
-import { reduxHooks } from 'hooks';
-
+import { useCourseData, useIsMasquerading } from 'hooks';
 import * as hooks from './hooks';
 
+jest.mock('react', () => ({
+  ...jest.requireActual('react'),
+  useMemo: jest.fn((fn) => fn()),
+}));
+
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useMasqueradeData: jest.fn(),
-    useCardEnrollmentData: jest.fn(),
-    useCardEntitlementData: jest.fn(),
-    useCardCourseRunData: jest.fn(),
-  },
+  ...jest.requireActual('hooks'),
+  useCourseData: jest.fn(),
+  useIsMasquerading: jest.fn(),
 }));
 
 const cardId = 'my-test-course-number';
@@ -38,25 +39,38 @@ describe('useActionDisabledState', () => {
       isAuditAccessExpired,
       resumeUrl,
       homeUrl,
+      availableSessions,
     } = { ...defaultData, ...args };
-    reduxHooks.useMasqueradeData.mockReturnValueOnce({ isMasquerading });
-    reduxHooks.useCardEnrollmentData.mockReturnValueOnce({
-      hasAccess,
-      isAudit,
-      isAuditAccessExpired,
-    });
-    reduxHooks.useCardEntitlementData.mockReturnValueOnce({
-      isEntitlement,
-      isFulfilled,
-      canChange,
-      hasSessions,
-    });
-    reduxHooks.useCardCourseRunData.mockReturnValueOnce({
-      resumeUrl,
-      homeUrl,
+    useIsMasquerading.mockReturnValue(isMasquerading);
+    useCourseData.mockReturnValue({
+      enrollment: {
+        hasAccess,
+        isAudit,
+        isAuditAccessExpired,
+        coursewareAccess: {
+          isStaff: false,
+          hasUnmetPrereqs: !hasAccess,
+          isTooEarly: !hasAccess,
+        },
+      },
+      entitlement: isEntitlement ? {
+        isEntitlement: true,
+        isFulfilled,
+        canChange,
+        hasSessions,
+        availableSessions,
+      } : {},
+      courseRun: {
+        resumeUrl,
+        homeUrl,
+      },
     });
   };
 
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
   const runHook = () => hooks.useActionDisabledState(cardId);
   describe('disableBeginCourse', () => {
     const testDisabled = (data, expected) => {
@@ -142,6 +156,7 @@ describe('useActionDisabledState', () => {
           hasAccess: true,
           canChange: true,
           hasSessions: true,
+          availableSessions: ['session1'],
         },
         false,
       );
diff --git a/src/containers/CourseCard/hooks.js b/src/containers/CourseCard/hooks.js
index 9a0f5ca77..76973d5bf 100644
--- a/src/containers/CourseCard/hooks.js
+++ b/src/containers/CourseCard/hooks.js
@@ -1,23 +1,6 @@
-import { useIntl } from '@edx/frontend-platform/i18n';
 import { useWindowSize, breakpoints } from '@openedx/paragon';
-import { reduxHooks } from 'hooks';
 
 export const useIsCollapsed = () => {
   const { width } = useWindowSize();
   return width < breakpoints.small.maxWidth;
 };
-
-export const useCardData = ({ cardId }) => {
-  const { formatMessage } = useIntl();
-  const { title, bannerImgSrc } = reduxHooks.useCardCourseData(cardId);
-  const { isEnrolled } = reduxHooks.useCardEnrollmentData(cardId);
-
-  return {
-    isEnrolled,
-    title,
-    bannerImgSrc,
-    formatMessage,
-  };
-};
-
-export default useCardData;
diff --git a/src/containers/CourseCard/hooks.test.js b/src/containers/CourseCard/hooks.test.js
index 86f89b697..9010873c2 100644
--- a/src/containers/CourseCard/hooks.test.js
+++ b/src/containers/CourseCard/hooks.test.js
@@ -1,58 +1,32 @@
-import { useIntl } from '@edx/frontend-platform/i18n';
+import { renderHook } from '@testing-library/react';
+import { useWindowSize } from '@openedx/paragon';
+import { useIsCollapsed } from './hooks';
 
-import { reduxHooks } from 'hooks';
-
-import * as hooks from './hooks';
-
-jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardCourseData: jest.fn(),
-    useCardEnrollmentData: jest.fn(),
+jest.mock('@openedx/paragon', () => ({
+  useWindowSize: jest.fn(),
+  breakpoints: {
+    small: {
+      maxWidth: 576,
+    },
   },
 }));
 
-jest.mock('@edx/frontend-platform/i18n', () => {
-  const { formatMessage } = jest.requireActual('testUtils');
-  return {
-    ...jest.requireActual('@edx/frontend-platform/i18n'),
-    useIntl: () => ({
-      formatMessage,
-    }),
-  };
-});
-
-const cardId = 'my-test-course-number';
-
-describe('CourseCard hooks', () => {
-  let out;
-  const { formatMessage } = useIntl();
-  beforeEach(() => {
+describe('useIsCollapsed', () => {
+  afterEach(() => {
     jest.clearAllMocks();
   });
 
-  describe('useCardData', () => {
-    const courseData = {
-      title: 'fake-title',
-      bannerImgSrc: 'my-banner-url',
-    };
-    const runHook = ({ course = {} }) => {
-      reduxHooks.useCardCourseData.mockReturnValueOnce({
-        ...courseData,
-        ...course,
-      });
-      reduxHooks.useCardEnrollmentData.mockReturnValue({ isEnrolled: 'test-is-enrolled' });
-      out = hooks.useCardData({ cardId });
-    };
-    beforeEach(() => {
-      runHook({});
-    });
-    it('forwards formatMessage from useIntl', () => {
-      expect(out.formatMessage).toEqual(formatMessage);
-    });
-    it('passes course title and banner URL form course data', () => {
-      expect(reduxHooks.useCardCourseData).toHaveBeenCalledWith(cardId);
-      expect(out.title).toEqual(courseData.title);
-      expect(out.bannerImgSrc).toEqual(courseData.bannerImgSrc);
-    });
+  it('should return true when window width is smaller than small breakpoint', () => {
+    useWindowSize.mockReturnValue({ width: 500 });
+    const { result } = renderHook(() => useIsCollapsed());
+    expect(result.current).toBe(true);
+    expect(useWindowSize).toHaveBeenCalled();
+  });
+
+  it('should return false when window width is larger than small breakpoint', () => {
+    useWindowSize.mockReturnValue({ width: 800 });
+    const { result } = renderHook(() => useIsCollapsed());
+    expect(result.current).toBe(false);
+    expect(useWindowSize).toHaveBeenCalled();
   });
 });
diff --git a/src/containers/CourseFilterControls/ActiveCourseFilters.jsx b/src/containers/CourseFilterControls/ActiveCourseFilters.jsx
index a121c749c..e25f57893 100644
--- a/src/containers/CourseFilterControls/ActiveCourseFilters.jsx
+++ b/src/containers/CourseFilterControls/ActiveCourseFilters.jsx
@@ -1,27 +1,24 @@
 import React from 'react';
-import PropTypes from 'prop-types';
 import { useIntl } from '@edx/frontend-platform/i18n';
 
 import { Button, Chip } from '@openedx/paragon';
 import { CloseSmall } from '@openedx/paragon/icons';
-import { reduxHooks } from 'hooks';
+import { useFilters } from 'data/context';
 
 import messages from './messages';
 import './index.scss';
 
-export const ActiveCourseFilters = ({
-  filters,
-  handleRemoveFilter,
-}) => {
+export const ActiveCourseFilters = () => {
   const { formatMessage } = useIntl();
-  const clearFilters = reduxHooks.useClearFilters();
+  const { filters, clearFilters, removeFilter } = useFilters();
+
   return (
     <div id="course-list-active-filters">
       {filters.map(filter => (
         <Chip
           key={filter}
           iconAfter={CloseSmall}
-          onClick={handleRemoveFilter(filter)}
+          onClick={() => removeFilter(filter)}
         >
           {formatMessage(messages[filter])}
         </Chip>
@@ -32,9 +29,5 @@ export const ActiveCourseFilters = ({
     </div>
   );
 };
-ActiveCourseFilters.propTypes = {
-  filters: PropTypes.arrayOf(PropTypes.string).isRequired,
-  handleRemoveFilter: PropTypes.func.isRequired,
-};
 
 export default ActiveCourseFilters;
diff --git a/src/containers/CourseFilterControls/ActiveCourseFilters.test.jsx b/src/containers/CourseFilterControls/ActiveCourseFilters.test.jsx
index aded20850..c499515f2 100644
--- a/src/containers/CourseFilterControls/ActiveCourseFilters.test.jsx
+++ b/src/containers/CourseFilterControls/ActiveCourseFilters.test.jsx
@@ -1,28 +1,54 @@
 import { render, screen } from '@testing-library/react';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 import { formatMessage } from 'testUtils';
+import { useFilters } from 'data/context';
 
 import { FilterKeys } from 'data/constants/app';
+import userEvent from '@testing-library/user-event';
 import ActiveCourseFilters from './ActiveCourseFilters';
 import messages from './messages';
 
 const filters = Object.values(FilterKeys);
 
+jest.mock('data/context', () => ({
+  useFilters: jest.fn(),
+}));
+
+const removeFiltersMock = jest.fn().mockName('removeFilter');
+const clearFiltersMock = jest.fn().mockName('clearFilters');
+useFilters.mockReturnValue({
+  filters,
+  removeFilter: removeFiltersMock,
+  clearFilters: clearFiltersMock,
+});
+
 describe('ActiveCourseFilters', () => {
-  const props = {
-    filters,
-    handleRemoveFilter: jest.fn().mockName('handleRemoveFilter'),
-  };
   it('renders chips correctly', () => {
-    render(<IntlProvider locale="en"><ActiveCourseFilters {...props} /></IntlProvider>);
+    render(<IntlProvider locale="en"><ActiveCourseFilters /></IntlProvider>);
     filters.map((key) => {
       const chip = screen.getByText(formatMessage(messages[key]));
       return expect(chip).toBeInTheDocument();
     });
   });
   it('renders button correctly', () => {
-    render(<IntlProvider locale="en"><ActiveCourseFilters {...props} /></IntlProvider>);
+    render(<IntlProvider locale="en"><ActiveCourseFilters /></IntlProvider>);
     const button = screen.getByRole('button', { name: formatMessage(messages.clearAll) });
     expect(button).toBeInTheDocument();
   });
+  it('should call onClick when button is clicked remove filter', async () => {
+    const user = userEvent.setup();
+    render(<IntlProvider locale="en"><ActiveCourseFilters /></IntlProvider>);
+    const removeButton = screen.getByRole('button', { name: formatMessage(messages[filters[0]]) });
+    await user.click(removeButton);
+    expect(removeFiltersMock).toHaveBeenCalledTimes(1);
+    expect(removeFiltersMock).toHaveBeenCalledWith(filters[0]);
+  });
+  it('should call onClick when button is clicked clear all filters', async () => {
+    const user = userEvent.setup();
+    render(<IntlProvider locale="en"><ActiveCourseFilters /></IntlProvider>);
+    screen.debug();
+    const clearAllButton = screen.getByRole('button', { name: formatMessage(messages.clearAll) });
+    await user.click(clearAllButton);
+    expect(clearFiltersMock).toHaveBeenCalledTimes(1);
+  });
 });
diff --git a/src/containers/CourseFilterControls/CourseFilterControls.jsx b/src/containers/CourseFilterControls/CourseFilterControls.jsx
index 4dd981865..5a28e2c6c 100644
--- a/src/containers/CourseFilterControls/CourseFilterControls.jsx
+++ b/src/containers/CourseFilterControls/CourseFilterControls.jsx
@@ -1,5 +1,4 @@
 import React from 'react';
-import PropTypes from 'prop-types';
 import { useIntl } from '@edx/frontend-platform/i18n';
 
 import {
@@ -14,44 +13,45 @@ import {
 } from '@openedx/paragon';
 import { Close, Tune } from '@openedx/paragon/icons';
 
-import { reduxHooks } from 'hooks';
-
+import { useInitializeLearnerHome } from 'data/hooks';
+import { useFilters } from 'data/context';
 import FilterForm from './components/FilterForm';
 import SortForm from './components/SortForm';
-import useCourseFilterControlsData from './hooks';
 import messages from './messages';
 
 import './index.scss';
 
-export const CourseFilterControls = ({
-  sortBy,
-  setSortBy,
-  filters,
-}) => {
+export const CourseFilterControls = () => {
+  const [isOpen, setIsOpen] = React.useState(false);
+  const [targetRef, setTargetRef] = React.useState(null);
   const { formatMessage } = useIntl();
-  const hasCourses = reduxHooks.useHasCourses();
+  const { data } = useInitializeLearnerHome();
+  const hasCourses = React.useMemo(() => data?.courses?.length > 0, [data]);
   const {
-    isOpen,
-    open,
-    close,
-    target,
-    setTarget,
-    handleFilterChange,
-    handleSortChange,
-  } = useCourseFilterControlsData({
-    filters,
-    setSortBy,
-  });
+    filters, sortBy, setSortBy, addFilter, removeFilter,
+  } = useFilters();
+
+  const openFiltersOptions = () => setIsOpen(true);
+  const closeFiltersOptions = () => setIsOpen(false);
+
+  const handleSortChange = (event) => {
+    setSortBy(event.target.value);
+  };
+
+  const handleFilterChange = ({ target: { checked, value } }) => {
+    const update = checked ? addFilter : removeFilter;
+    update(value);
+  };
   const { width } = useWindowSize();
   const isMobile = width < breakpoints.small.minWidth;
 
   return (
     <div id="course-filter-controls">
       <Button
-        ref={setTarget}
+        ref={setTargetRef}
         variant="outline-primary"
         iconBefore={Tune}
-        onClick={open}
+        onClick={openFiltersOptions}
         disabled={!hasCourses}
       >
         {formatMessage(messages.refine)}
@@ -63,7 +63,7 @@ export const CourseFilterControls = ({
               className="w-75"
               position="left"
               show={isOpen}
-              onClose={close}
+              onClose={closeFiltersOptions}
             >
               <div className="p-1 mr-3">
                 <b>{formatMessage(messages.refine)}</b>
@@ -76,16 +76,16 @@ export const CourseFilterControls = ({
                 <SortForm {...{ sortBy, handleSortChange }} />
               </div>
               <div className="pgn__modal-close-container">
-                <ModalCloseButton variant="tertiary" onClick={close}>
+                <ModalCloseButton variant="tertiary" onClick={closeFiltersOptions}>
                   <Icon src={Close} />
                 </ModalCloseButton>
               </div>
             </Sheet>
           ) : (
             <ModalPopup
-              positionRef={target}
+              positionRef={targetRef}
               isOpen={isOpen}
-              onClose={close}
+              onClose={closeFiltersOptions}
               placement="bottom-end"
             >
               <div
@@ -106,10 +106,5 @@ export const CourseFilterControls = ({
     </div>
   );
 };
-CourseFilterControls.propTypes = {
-  sortBy: PropTypes.string.isRequired,
-  setSortBy: PropTypes.func.isRequired,
-  filters: PropTypes.arrayOf(PropTypes.string).isRequired,
-};
 
 export default CourseFilterControls;
diff --git a/src/containers/CourseFilterControls/CourseFilterControls.test.jsx b/src/containers/CourseFilterControls/CourseFilterControls.test.jsx
index affc668b2..614fae470 100644
--- a/src/containers/CourseFilterControls/CourseFilterControls.test.jsx
+++ b/src/containers/CourseFilterControls/CourseFilterControls.test.jsx
@@ -1,20 +1,19 @@
-import { render, screen } from '@testing-library/react';
+import { render, screen, waitFor } from '@testing-library/react';
 import { formatMessage } from 'testUtils';
 import { breakpoints, useWindowSize } from '@openedx/paragon';
-import { reduxHooks } from 'hooks';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 import { FilterKeys, SortKeys } from 'data/constants/app';
+import { useInitializeLearnerHome } from 'data/hooks';
+import { useFilters } from 'data/context';
 
+import userEvent from '@testing-library/user-event';
 import messages from './messages';
 import CourseFilterControls from './CourseFilterControls';
-import useCourseFilterControlsData from './hooks';
 
-jest.mock('hooks', () => ({
-  reduxHooks: { useHasCourses: jest.fn() },
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn().mockReturnValue({ data: { courses: [1, 2, 3] } }),
 }));
 
-jest.mock('./hooks', () => jest.fn());
-
 jest.mock('@openedx/paragon', () => ({
   ...jest.requireActual('@openedx/paragon'),
   useWindowSize: jest.fn(),
@@ -22,54 +21,123 @@ jest.mock('@openedx/paragon', () => ({
 
 const filters = Object.values(FilterKeys);
 
-const mockControlsData = {
-  isOpen: false,
-  open: jest.fn().mockName('open'),
-  close: jest.fn().mockName('close'),
-  target: 'target-test',
-  setTarget: jest.fn(),
-  handleFilterChange: jest.fn().mockName('handleFilterChange'),
-  handleSortChange: jest.fn().mockName('handleSortChange'),
-};
+jest.mock('data/context', () => ({
+  useFilters: jest.fn(),
+}));
 
-describe('CourseFilterControls', () => {
-  const props = {
-    sortBy: SortKeys.enrolled,
-    setSortBy: jest.fn().mockName('setSortBy'),
-    filters,
-  };
+const setSortByMock = jest.fn().mockName('setSortBy');
+useFilters.mockReturnValue({
+  filters,
+  removeFilter: jest.fn().mockName('removeFilter'),
+  clearFilters: jest.fn().mockName('clearFilters'),
+  setSortBy: setSortByMock,
+  addFilter: jest.fn().mockName('addFilter'),
+});
 
+describe('CourseFilterControls', () => {
   describe('mobile and open', () => {
-    it('should render sheet', () => {
-      reduxHooks.useHasCourses.mockReturnValue(true);
-      useCourseFilterControlsData.mockReturnValue({ ...mockControlsData, isOpen: true });
-      useWindowSize.mockReturnValueOnce({ width: breakpoints.small.minWidth - 1 });
-      render(<IntlProvider locale="en"><CourseFilterControls {...props} /></IntlProvider>);
-      const sheet = screen.getByRole('presentation', { hidden: true });
-      expect(sheet).toBeInTheDocument();
-      expect(sheet.parentElement).toHaveClass('sheet-container');
+    it('should render sheet', async () => {
+      const user = userEvent.setup();
+      useWindowSize.mockReturnValue({ width: breakpoints.small.minWidth - 1 });
+      render(<IntlProvider locale="en"><CourseFilterControls /></IntlProvider>);
+      const filtersButton = screen.getByRole('button', { name: 'Refine' });
+      await user.click(filtersButton);
+      await waitFor(() => {
+        const sheet = screen.getByRole('presentation', { hidden: true });
+        expect(sheet).toBeInTheDocument();
+        expect(sheet.parentElement).toHaveClass('sheet-container');
+      });
     });
   });
   describe('is not mobile', () => {
-    it('should have button disabled', () => {
-      reduxHooks.useHasCourses.mockReturnValue(true);
-      useCourseFilterControlsData.mockReturnValue({ ...mockControlsData, isOpen: true });
-      useWindowSize.mockReturnValueOnce({ width: breakpoints.small.minWidth });
-      render(<IntlProvider locale="en"><CourseFilterControls {...props} /></IntlProvider>);
-      const filterForm = screen.getByText(messages.courseStatus.defaultMessage);
-      const modal = filterForm.closest('div.pgn__modal-popup__tooltip');
-      expect(modal).toBeInTheDocument();
+    it('should have button disabled', async () => {
+      const user = userEvent.setup();
+      useWindowSize.mockReturnValue({ width: breakpoints.small.minWidth });
+      render(<IntlProvider locale="en"><CourseFilterControls /></IntlProvider>);
+      const filtersButton = screen.getByRole('button', { name: 'Refine' });
+      await user.click(filtersButton);
+      await waitFor(() => {
+        const filterForm = screen.getByText(messages.courseStatus.defaultMessage);
+        const modal = filterForm.closest('div.pgn__modal-popup__tooltip');
+        expect(modal).toBeInTheDocument();
+      });
     });
   });
   describe('no courses', () => {
     it('should have button disabled', () => {
-      reduxHooks.useHasCourses.mockReturnValue(false);
-      useCourseFilterControlsData.mockReturnValue(mockControlsData);
+      useInitializeLearnerHome.mockReturnValue({ data: { courses: [] } });
       useWindowSize.mockReturnValue({ width: breakpoints.small.minWidth });
-      render(<IntlProvider locale="en"><CourseFilterControls {...props} /></IntlProvider>);
+      render(<IntlProvider locale="en"><CourseFilterControls /></IntlProvider>);
       const button = screen.getByRole('button', { name: formatMessage(messages.refine) });
       expect(button).toBeInTheDocument();
       expect(button).toBeDisabled();
     });
   });
+  describe('with courses', () => {
+    it('should have button enabled', () => {
+      useInitializeLearnerHome.mockReturnValue({ data: { courses: [1, 2, 3] } });
+      useWindowSize.mockReturnValue({ width: breakpoints.small.minWidth });
+      render(<IntlProvider locale="en"><CourseFilterControls /></IntlProvider>);
+      const button = screen.getByRole('button', { name: formatMessage(messages.refine) });
+      expect(button).toBeInTheDocument();
+      expect(button).toBeEnabled();
+    });
+    it('should call setSortBy on sort change', async () => {
+      const user = userEvent.setup();
+      useInitializeLearnerHome.mockReturnValue({ data: { courses: [1, 2, 3] } });
+      useWindowSize.mockReturnValue({ width: breakpoints.small.minWidth });
+      render(<IntlProvider locale="en"><CourseFilterControls /></IntlProvider>);
+      const filtersButton = screen.getByRole('button', { name: 'Refine' });
+      await user.click(filtersButton);
+      await waitFor(async () => {
+        const sortRadio = screen.getByRole('radio', { name: formatMessage(messages.sortTitle) });
+        await user.click(sortRadio);
+        expect(setSortByMock).toHaveBeenCalledWith(SortKeys.title);
+      });
+    });
+    it('should call addFilter on filter check', async () => {
+      const user = userEvent.setup();
+      const addFilterMock = jest.fn().mockName('addFilter');
+      const removeFilterMock = jest.fn().mockName('removeFilter');
+      useFilters.mockReturnValue({
+        filters: [],
+        removeFilter: removeFilterMock,
+        clearFilters: jest.fn().mockName('clearFilters'),
+        setSortBy: jest.fn().mockName('setSortBy'),
+        addFilter: addFilterMock,
+      });
+      useInitializeLearnerHome.mockReturnValue({ data: { courses: [1, 2, 3] } });
+      useWindowSize.mockReturnValue({ width: breakpoints.small.minWidth });
+      render(<IntlProvider locale="en"><CourseFilterControls /></IntlProvider>);
+      const filtersButton = screen.getByRole('button', { name: 'Refine' });
+      await user.click(filtersButton);
+      await waitFor(async () => {
+        const filterCheckbox = screen.getByText('In-Progress');
+        await user.click(filterCheckbox);
+        expect(addFilterMock).toHaveBeenCalledWith(FilterKeys.inProgress);
+      });
+    });
+    it('should call removeFilter on filter uncheck', async () => {
+      const user = userEvent.setup();
+      const addFilterMock = jest.fn().mockName('addFilter');
+      const removeFilterMock = jest.fn().mockName('removeFilter');
+      useFilters.mockReturnValue({
+        filters: [FilterKeys.inProgress],
+        removeFilter: removeFilterMock,
+        clearFilters: jest.fn().mockName('clearFilters'),
+        setSortBy: jest.fn().mockName('setSortBy'),
+        addFilter: addFilterMock,
+      });
+      useInitializeLearnerHome.mockReturnValue({ data: { courses: [1, 2, 3] } });
+      useWindowSize.mockReturnValue({ width: breakpoints.small.minWidth });
+      render(<IntlProvider locale="en"><CourseFilterControls /></IntlProvider>);
+      const filtersButton = screen.getByRole('button', { name: 'Refine' });
+      await user.click(filtersButton);
+      await waitFor(async () => {
+        const filterCheckbox = screen.getByText('In-Progress');
+        await user.click(filterCheckbox);
+        expect(removeFilterMock).toHaveBeenCalledWith(FilterKeys.inProgress);
+      });
+    });
+  });
 });
diff --git a/src/containers/CourseFilterControls/hooks.js b/src/containers/CourseFilterControls/hooks.js
deleted file mode 100644
index b19690193..000000000
--- a/src/containers/CourseFilterControls/hooks.js
+++ /dev/null
@@ -1,60 +0,0 @@
-import React from 'react';
-import { useToggle } from '@openedx/paragon';
-
-import { StrictDict } from 'utils';
-import track from 'tracking';
-import { reduxHooks } from 'hooks';
-
-import * as module from './hooks';
-
-export const state = StrictDict({
-  target: (val) => React.useState(val), // eslint-disable-line
-});
-
-/**
- * Sets up a toggle for the modal as well as helper functions for handling changes to the form controls.
- *
- * @param {array} filters Currently active course filters
- * @param {function} setSortBy Set function for sorting the course list
- * @returns {object} data and functions for managing the CourseFilterControls component
- */
-export const useCourseFilterControlsData = ({
-  filters,
-  setSortBy,
-}) => {
-  const [isOpen, toggleOpen, toggleClose] = useToggle(false);
-  const [target, setTarget] = module.state.target(null);
-
-  const addFilter = reduxHooks.useAddFilter();
-  const removeFilter = reduxHooks.useRemoveFilter();
-
-  const handleFilterChange = ({ target: { checked, value } }) => {
-    const update = checked ? addFilter : removeFilter;
-    update(value);
-  };
-  const handleSortChange = ({ target: { value } }) => {
-    setSortBy(value);
-  };
-
-  const open = () => {
-    track.filter.filterClicked();
-    toggleOpen();
-  };
-
-  const close = () => {
-    track.filter.filterOptionSelected(filters);
-    toggleClose();
-  };
-
-  return {
-    isOpen,
-    open,
-    close,
-    target,
-    setTarget,
-    handleFilterChange,
-    handleSortChange,
-  };
-};
-
-export default useCourseFilterControlsData;
diff --git a/src/containers/CourseFilterControls/hooks.test.js b/src/containers/CourseFilterControls/hooks.test.js
deleted file mode 100644
index 639f2b294..000000000
--- a/src/containers/CourseFilterControls/hooks.test.js
+++ /dev/null
@@ -1,122 +0,0 @@
-import { useToggle } from '@openedx/paragon';
-
-import { MockUseState } from 'testUtils';
-import { reduxHooks } from 'hooks';
-
-import track from 'tracking';
-
-import * as hooks from './hooks';
-
-jest.mock('@openedx/paragon', () => ({
-  ...jest.requireActual('@openedx/paragon'),
-  useToggle: jest.fn().mockImplementation((val) => [
-    val,
-    jest.fn().mockName('useToggle.setTrue'),
-    jest.fn().mockName('useToggle.setFalse'),
-  ]),
-}));
-
-jest.mock('tracking', () => ({
-  filter: {
-    filterClicked: jest.fn(),
-    filterOptionSelected: jest.fn(),
-  },
-}));
-
-jest.mock('hooks', () => ({
-  reduxHooks: {
-    useAddFilter: jest.fn(),
-    useRemoveFilter: jest.fn(),
-  },
-}));
-
-const state = new MockUseState(hooks);
-
-describe('CourseFilterControls hooks', () => {
-  let out;
-  const filters = ['a', 'b', 'c'];
-  const setSortBy = jest.fn();
-
-  const removeFilter = jest.fn();
-  reduxHooks.useRemoveFilter.mockReturnValue(removeFilter);
-  const addFilter = jest.fn();
-  reduxHooks.useAddFilter.mockReturnValue(addFilter);
-
-  const toggleOpen = jest.fn();
-  const toggleClose = jest.fn();
-
-  describe('state values', () => {
-    state.testGetter(state.keys.target);
-  });
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('useCourseFilterControlsData', () => {
-    beforeEach(() => {
-      useToggle.mockReturnValueOnce([false, toggleOpen, toggleClose]);
-      state.mock();
-      out = hooks.useCourseFilterControlsData({
-        filters,
-        setSortBy,
-      });
-    });
-    afterEach(state.restore);
-
-    test('default state', () => {
-      expect(out.isOpen).toEqual(false);
-      expect(out.target).toEqual(state.stateVals.target);
-    });
-
-    test('open calls toggleOpen and track.filter.filterClicked', () => {
-      out.open();
-      expect(toggleOpen).toHaveBeenCalled();
-      expect(track.filter.filterClicked).toHaveBeenCalled();
-    });
-
-    test('close calls toggleClose and track.filter.filterOptionSelected', () => {
-      out.close();
-      expect(toggleClose).toHaveBeenCalled();
-      expect(track.filter.filterOptionSelected).toHaveBeenCalledWith(filters);
-    });
-
-    test('isOpen is true when target is set', () => {
-      useToggle.mockReturnValueOnce([true, toggleOpen, toggleClose]);
-      expect(out.target).toEqual(null);
-      state.mockVal(state.keys.target, 'foo');
-      out = hooks.useCourseFilterControlsData({
-        filters,
-        setSortBy,
-      });
-      expect(out.isOpen).toEqual(true);
-      expect(out.target).toEqual('foo');
-    });
-
-    test('handle filter change', () => {
-      const value = 'a';
-      out.handleFilterChange({
-        target: {
-          checked: true,
-          value,
-        },
-      });
-      expect(addFilter).toHaveBeenCalledWith(value);
-      out.handleFilterChange({
-        target: {
-          checked: false,
-          value,
-        },
-      });
-      expect(removeFilter).toHaveBeenCalledWith(value);
-    });
-    test('handle sort change', () => {
-      const value = 'a';
-      out.handleSortChange({
-        target: {
-          value,
-        },
-      });
-      expect(setSortBy).toHaveBeenCalledWith(value);
-    });
-  });
-});
diff --git a/src/containers/CoursesPanel/CourseList/index.jsx b/src/containers/CoursesPanel/CourseList/index.jsx
index 2b178b23d..c2297d7eb 100644
--- a/src/containers/CoursesPanel/CourseList/index.jsx
+++ b/src/containers/CoursesPanel/CourseList/index.jsx
@@ -11,14 +11,15 @@ import { useIsCollapsed } from './hooks';
 
 export const CourseList = ({ courseListData }) => {
   const {
-    filterOptions, setPageNumber, numPages, showFilters, visibleList,
+    setPageNumber, numPages, visibleList, showFilters,
   } = courseListData;
+
   const isCollapsed = useIsCollapsed();
   return (
     <>
       {showFilters && (
         <div id="course-list-active-filters-container">
-          <ActiveCourseFilters {...filterOptions} />
+          <ActiveCourseFilters />
         </div>
       )}
       <div className="d-flex flex-column flex-grow-1">
@@ -42,7 +43,6 @@ export const CourseList = ({ courseListData }) => {
 export const courseListDataShape = PropTypes.shape({
   showFilters: PropTypes.bool.isRequired,
   visibleList: PropTypes.arrayOf(PropTypes.shape()).isRequired,
-  filterOptions: PropTypes.shape().isRequired,
   numPages: PropTypes.number.isRequired,
   setPageNumber: PropTypes.func.isRequired,
 });
diff --git a/src/containers/CoursesPanel/NoCoursesView/index.jsx b/src/containers/CoursesPanel/NoCoursesView/index.jsx
index f7a38c68e..3f0403fce 100644
--- a/src/containers/CoursesPanel/NoCoursesView/index.jsx
+++ b/src/containers/CoursesPanel/NoCoursesView/index.jsx
@@ -5,14 +5,15 @@ import { Search } from '@openedx/paragon/icons';
 import { baseAppUrl } from 'data/services/lms/urls';
 
 import emptyCourseSVG from 'assets/empty-course.svg';
-import { reduxHooks } from 'hooks';
+import { useInitializeLearnerHome } from 'data/hooks';
 
 import messages from './messages';
 import './index.scss';
 
 export const NoCoursesView = () => {
   const { formatMessage } = useIntl();
-  const { courseSearchUrl } = reduxHooks.usePlatformSettingsData();
+  const { data: learnerData } = useInitializeLearnerHome();
+  const courseSearchUrl = learnerData?.platformSettings?.courseSearchUrl || '';
   return (
     <div
       id="no-courses-content-view"
diff --git a/src/containers/CoursesPanel/NoCoursesView/index.test.jsx b/src/containers/CoursesPanel/NoCoursesView/index.test.jsx
index 8f3ed46f9..2d7c56a2d 100644
--- a/src/containers/CoursesPanel/NoCoursesView/index.test.jsx
+++ b/src/containers/CoursesPanel/NoCoursesView/index.test.jsx
@@ -8,12 +8,14 @@ import messages from './messages';
 
 const courseSearchUrl = '/course-search-url';
 
-jest.mock('hooks', () => ({
-  reduxHooks: {
-    usePlatformSettingsData: jest.fn(() => ({
-      courseSearchUrl,
-    })),
-  },
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn(() => ({
+    data: {
+      platformSettings: {
+        courseSearchUrl,
+      },
+    },
+  })),
 }));
 
 describe('NoCoursesView', () => {
diff --git a/src/containers/CoursesPanel/hooks.js b/src/containers/CoursesPanel/hooks.js
deleted file mode 100644
index 2cdeeb3ed..000000000
--- a/src/containers/CoursesPanel/hooks.js
+++ /dev/null
@@ -1,54 +0,0 @@
-import React from 'react';
-
-import { ListPageSize, SortKeys } from 'data/constants/app';
-import { reduxHooks } from 'hooks';
-import { StrictDict } from 'utils';
-
-import * as module from './hooks';
-
-export const state = StrictDict({
-  sortBy: (val) => React.useState(val), // eslint-disable-line
-});
-
-/**
- * Filters are fetched from the store and used to generate a list of "visible" courses.
- * Other values returned and used for the layout of the CoursesPanel component are:
- * the current page number, the sorting method, and whether or not to enable filters and pagination.
- *
- * @returns data for the CoursesPanel component
- */
-export const useCourseListData = () => {
-  const filters = reduxHooks.useFilters();
-  const removeFilter = reduxHooks.useRemoveFilter();
-  const pageNumber = reduxHooks.usePageNumber();
-  const setPageNumber = reduxHooks.useSetPageNumber();
-
-  const [sortBy, setSortBy] = module.state.sortBy(SortKeys.enrolled);
-
-  const querySearch = new URLSearchParams(window.location.search);
-  const disablePagination = querySearch.get('disable_pagination');
-
-  const { numPages, visibleList } = reduxHooks.useCurrentCourseList({
-    sortBy,
-    filters,
-    pageSize: Number(disablePagination) === 1 ? 0 : ListPageSize,
-  });
-
-  const handleRemoveFilter = (filter) => () => removeFilter(filter);
-
-  return {
-    pageNumber,
-    numPages,
-    setPageNumber,
-    visibleList,
-    filterOptions: {
-      sortBy,
-      setSortBy,
-      filters,
-      handleRemoveFilter,
-    },
-    showFilters: filters.length > 0,
-  };
-};
-
-export default useCourseListData;
diff --git a/src/containers/CoursesPanel/hooks.test.js b/src/containers/CoursesPanel/hooks.test.js
deleted file mode 100644
index 64f608ca8..000000000
--- a/src/containers/CoursesPanel/hooks.test.js
+++ /dev/null
@@ -1,115 +0,0 @@
-import { MockUseState } from 'testUtils';
-import { reduxHooks } from 'hooks';
-import { ListPageSize, SortKeys } from 'data/constants/app';
-import * as hooks from './hooks';
-
-jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCurrentCourseList: jest.fn(),
-    usePageNumber: jest.fn(() => 23),
-    useSetPageNumber: jest.fn(),
-    useFilters: jest.fn(),
-    useRemoveFilter: jest.fn(),
-  },
-}));
-
-const mockGet = jest.fn(() => ({}));
-
-global.URLSearchParams = jest.fn().mockImplementation(() => ({
-  get: mockGet,
-}));
-
-const state = new MockUseState(hooks);
-
-const testList = ['a', 'b'];
-const testListData = {
-  numPages: 52,
-  visibleList: testList,
-};
-const testSortBy = 'fake sort option';
-const testFilters = ['some', 'fake', 'filters'];
-
-const setPageNumber = jest.fn(val => ({ setPageNumber: val }));
-reduxHooks.useSetPageNumber.mockReturnValue(setPageNumber);
-
-const removeFilter = jest.fn();
-reduxHooks.useRemoveFilter.mockReturnValue(removeFilter);
-reduxHooks.useFilters.mockReturnValue(['some', 'fake', 'filters']);
-
-describe('CourseList hooks', () => {
-  let out;
-
-  reduxHooks.useCurrentCourseList.mockReturnValue(testListData);
-
-  describe('state values', () => {
-    state.testGetter(state.keys.sortBy);
-    jest.clearAllMocks();
-  });
-
-  describe('useCourseListData', () => {
-    afterEach(state.restore);
-    beforeEach(() => {
-      state.mock();
-      state.mockVal(state.keys.sortBy, testSortBy);
-      out = hooks.useCourseListData();
-    });
-    describe('behavior', () => {
-      it('initializes sort with enrollment date', () => {
-        state.expectInitializedWith(state.keys.sortBy, SortKeys.enrolled);
-      });
-      it('loads current course list with sortBy, filters, and page size', () => {
-        expect(reduxHooks.useCurrentCourseList).toHaveBeenCalledWith({
-          sortBy: testSortBy,
-          filters: testFilters,
-          pageSize: ListPageSize,
-        });
-      });
-      it('loads current course list with page size 0 if/when there is query param disable_pagination=1', () => {
-        state.mock();
-        state.mockVal(state.keys.sortBy, testSortBy);
-        mockGet.mockReturnValueOnce('1');
-        out = hooks.useCourseListData();
-        expect(reduxHooks.useCurrentCourseList).toHaveBeenCalledWith({
-          sortBy: testSortBy,
-          filters: testFilters,
-          pageSize: 0,
-        });
-      });
-    });
-    describe('output', () => {
-      test('pageNumber loads from usePageNumber hook', () => {
-        expect(out.pageNumber).toEqual(reduxHooks.usePageNumber());
-      });
-      test('numPages and visible list load from useCurrentCourseList hook', () => {
-        expect(out.numPages).toEqual(testListData.numPages);
-        expect(out.visibleList).toEqual(testListData.visibleList);
-      });
-      test('showFilters is true iff filters is not empty', () => {
-        expect(out.showFilters).toEqual(true);
-        state.mockVal(state.keys.sortBy, testSortBy);
-        reduxHooks.useFilters.mockReturnValueOnce([]);
-        out = hooks.useCourseListData();
-        // don't show filter when list is empty.
-        expect(out.showFilters).toEqual(false);
-      });
-      describe('filterOptions', () => {
-        test('sortBy and setSortBy are connected to the state value', () => {
-          expect(out.filterOptions.sortBy).toEqual(testSortBy);
-          expect(out.filterOptions.setSortBy).toEqual(state.setState.sortBy);
-        });
-        test('filters passed by useFilters hook', () => {
-          expect(out.filterOptions.filters).toEqual(testFilters);
-        });
-        test('handleRemoveFilter creates callback to call setFilter.remove', () => {
-          const cb = out.filterOptions.handleRemoveFilter(testFilters[0]);
-          expect(removeFilter).not.toHaveBeenCalled();
-          cb();
-          expect(removeFilter).toHaveBeenCalledWith(testFilters[0]);
-        });
-        test('setPageNumber dispatches setPageNumber action with passed value', () => {
-          expect(out.setPageNumber(2)).toEqual(setPageNumber(2));
-        });
-      });
-    });
-  });
-});
diff --git a/src/containers/CoursesPanel/index.jsx b/src/containers/CoursesPanel/index.jsx
index 6bf525ab4..0eedf7cc8 100644
--- a/src/containers/CoursesPanel/index.jsx
+++ b/src/containers/CoursesPanel/index.jsx
@@ -1,15 +1,15 @@
-import React from 'react';
+import React, { useMemo } from 'react';
 
 import { useIntl } from '@edx/frontend-platform/i18n';
-
-import { reduxHooks } from 'hooks';
+import { useInitializeLearnerHome } from 'data/hooks';
 import {
   CourseFilterControls,
 } from 'containers/CourseFilterControls';
 import CourseListSlot from 'plugin-slots/CourseListSlot';
 import NoCoursesViewSlot from 'plugin-slots/NoCoursesViewSlot';
+import { useFilters } from 'data/context';
 
-import { useCourseListData } from './hooks';
+import { getVisibleList, getTransformedCourseDataList } from 'utils/dataTransformers';
 
 import messages from './messages';
 
@@ -22,8 +22,33 @@ import './index.scss';
 */
 export const CoursesPanel = () => {
   const { formatMessage } = useIntl();
-  const hasCourses = reduxHooks.useHasCourses();
-  const courseListData = useCourseListData();
+  const { data } = useInitializeLearnerHome();
+  const hasCourses = useMemo(() => data?.courses?.length > 0, [data]);
+
+  const {
+    filters, sortBy, pageNumber, setPageNumber,
+  } = useFilters();
+  const { visibleList, numPages } = useMemo(() => {
+    let transformedCourses = [];
+    if (data?.courses?.length) {
+      transformedCourses = getTransformedCourseDataList(data.courses);
+    }
+    return getVisibleList(
+      transformedCourses,
+      filters,
+      sortBy,
+      pageNumber,
+    );
+  }, [data, filters, sortBy, pageNumber]);
+
+  const courseListData = {
+    filterOptions: filters,
+    setPageNumber,
+    numPages,
+    visibleList,
+    showFilters: filters.length > 0,
+  };
+
   return (
     <div className="course-list-container">
       <div className="course-list-heading-container">
diff --git a/src/containers/CoursesPanel/index.test.jsx b/src/containers/CoursesPanel/index.test.jsx
index 0c6aa9a16..35c50afc3 100644
--- a/src/containers/CoursesPanel/index.test.jsx
+++ b/src/containers/CoursesPanel/index.test.jsx
@@ -1,26 +1,26 @@
 import { render, screen } from '@testing-library/react';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
-import { FilterKeys } from 'data/constants/app';
-import { reduxHooks } from 'hooks';
+import { useInitializeLearnerHome } from 'data/hooks';
 
 import messagesNoCourses from 'containers/CoursesPanel/NoCoursesView/messages';
-import { useCourseListData } from './hooks';
 import CoursesPanel from '.';
 import messages from './messages';
 
-const courseSearchUrl = '/course-search-url';
-
-jest.mock('hooks', () => ({
-  reduxHooks: {
-    useHasCourses: jest.fn(),
-    usePlatformSettingsData: jest.fn(() => ({
-      courseSearchUrl,
-    })),
-  },
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn(() => ({
+    data: {
+      courses: [{ id: 1 }, { id: 2 }],
+    },
+  })),
 }));
 
-jest.mock('./hooks', () => ({
-  useCourseListData: jest.fn(),
+jest.mock('data/context/FiltersProvider', () => ({
+  useFilters: jest.fn(() => ({
+    filters: [],
+    sortBy: 'enrolled',
+    pageNumber: 1,
+    setPageNumber: jest.fn(),
+  })),
 }));
 
 jest.mock('containers/CourseCard', () => jest.fn(() => <div>CourseCard</div>));
@@ -33,30 +33,14 @@ jest.mock('@openedx/frontend-plugin-framework', () => ({
   PluginSlot: 'PluginSlot',
 }));
 
-const filters = Object.values(FilterKeys);
-
-reduxHooks.useHasCourses.mockReturnValue(true);
-
 describe('CoursesPanel', () => {
-  const defaultCourseListData = {
-    filterOptions: { filters, handleRemoveFilter: jest.fn() },
-    numPages: 1,
-    setPageNumber: jest.fn().mockName('setPageNumber'),
-    showFilters: false,
-    visibleList: [],
-  };
-
   const createWrapper = (courseListData) => {
-    useCourseListData.mockReturnValue({
-      ...defaultCourseListData,
-      ...courseListData,
-    });
+    useInitializeLearnerHome.mockReturnValue({ data: { courses: courseListData?.visibleList || [] } });
     return render(<IntlProvider locale="en"><CoursesPanel /></IntlProvider>);
   };
 
   describe('no courses', () => {
     it('should render no courses view slot', () => {
-      reduxHooks.useHasCourses.mockReturnValue(false);
       createWrapper();
       const imgNoCourses = screen.getByRole('img', { name: messagesNoCourses.bannerAlt.defaultMessage });
       expect(imgNoCourses).toBeInTheDocument();
@@ -67,19 +51,16 @@ describe('CoursesPanel', () => {
   describe('with courses', () => {
     it('should render courselist', () => {
       const visibleList = [{ cardId: 'foo' }, { cardId: 'bar' }, { cardId: 'baz' }];
-      reduxHooks.useHasCourses.mockReturnValue(true);
       createWrapper({ visibleList });
       const courseCards = screen.getAllByText('CourseCard');
       expect(courseCards.length).toEqual(visibleList.length);
     });
     it('displays course filter controls', () => {
-      reduxHooks.useHasCourses.mockReturnValue(true);
       createWrapper();
       expect(screen.getByText('CourseFilterControls')).toBeInTheDocument();
     });
 
     it('displays course list slot when courses exist', () => {
-      reduxHooks.useHasCourses.mockReturnValue(true);
       const visibleList = [{ cardId: 'foo' }, { cardId: 'bar' }, { cardId: 'baz' }];
       createWrapper({ visibleList });
       const heading = screen.getByText(messages.myCourses.defaultMessage);
diff --git a/src/containers/Dashboard/DashboardLayout.test.jsx b/src/containers/Dashboard/DashboardLayout.test.jsx
index c9d5acc62..0831276fe 100644
--- a/src/containers/Dashboard/DashboardLayout.test.jsx
+++ b/src/containers/Dashboard/DashboardLayout.test.jsx
@@ -4,6 +4,16 @@ import { IntlProvider } from '@edx/frontend-platform/i18n';
 import hooks from './hooks';
 import DashboardLayout from './DashboardLayout';
 
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn().mockReturnValue({
+    data: {
+      platformSettings: {
+        courseSearchUrl: '/courses',
+      },
+    },
+  }),
+}));
+
 jest.mock('./hooks', () => ({
   useDashboardLayoutData: jest.fn(),
 }));
diff --git a/src/containers/Dashboard/hooks.js b/src/containers/Dashboard/hooks.js
index 73ddf34d1..d134a4eab 100644
--- a/src/containers/Dashboard/hooks.js
+++ b/src/containers/Dashboard/hooks.js
@@ -1,7 +1,6 @@
 import React from 'react';
 import { useWindowSize, breakpoints } from '@openedx/paragon';
 import { useIntl } from '@edx/frontend-platform/i18n';
-import { apiHooks } from 'hooks';
 import { StrictDict } from 'utils';
 
 import appMessages from 'messages';
@@ -11,11 +10,6 @@ export const state = StrictDict({
   sidebarShowing: (val) => React.useState(val), // eslint-disable-line
 });
 
-export const useInitializeDashboard = () => {
-  const initialize = apiHooks.useInitializeApp();
-  React.useEffect(() => { initialize(); }, []); // eslint-disable-line
-};
-
 export const useDashboardMessages = () => {
   const { formatMessage } = useIntl();
   return {
@@ -37,6 +31,5 @@ export const useDashboardLayoutData = () => {
 
 export default {
   useDashboardLayoutData,
-  useInitializeDashboard,
   useDashboardMessages,
 };
diff --git a/src/containers/Dashboard/hooks.test.js b/src/containers/Dashboard/hooks.test.js
index 1af97a2d1..afa6ccd82 100644
--- a/src/containers/Dashboard/hooks.test.js
+++ b/src/containers/Dashboard/hooks.test.js
@@ -1,9 +1,6 @@
-import React from 'react';
-
 import { useIntl } from '@edx/frontend-platform/i18n';
 import { useWindowSize, breakpoints } from '@openedx/paragon';
 
-import { apiHooks } from 'hooks';
 import { MockUseState } from 'testUtils';
 
 import appMessages from 'messages';
@@ -25,12 +22,6 @@ jest.mock('@edx/frontend-platform/i18n', () => {
   };
 });
 
-jest.mock('hooks', () => ({
-  apiHooks: {
-    useInitializeApp: jest.fn(),
-  },
-}));
-
 jest.mock('react', () => ({
   ...jest.requireActual('react'),
   useEffect: jest.fn((cb, prereqs) => ({ useEffect: { cb, prereqs } })),
@@ -38,8 +29,6 @@ jest.mock('react', () => ({
 
 const state = new MockUseState(hooks);
 
-const initializeApp = jest.fn();
-apiHooks.useInitializeApp.mockReturnValue(initializeApp);
 useWindowSize.mockReturnValue({ width: 20 });
 breakpoints.large = { maxWidth: 30 };
 describe('CourseCard hooks', () => {
@@ -77,16 +66,6 @@ describe('CourseCard hooks', () => {
       });
     });
   });
-  describe('useInitializeDashboard', () => {
-    it('dispatches initialize thunk action on component load', () => {
-      hooks.useInitializeDashboard();
-      const [cb, prereqs] = React.useEffect.mock.calls[0];
-      expect(prereqs).toEqual([]);
-      expect(initializeApp).not.toHaveBeenCalled();
-      cb();
-      expect(initializeApp).toHaveBeenCalledWith();
-    });
-  });
   describe('useDashboardMessages', () => {
     it('returns spinner screen reader text', () => {
       expect(hooks.useDashboardMessages().spinnerScreenReaderText).toEqual(
diff --git a/src/containers/Dashboard/index.jsx b/src/containers/Dashboard/index.jsx
index ebdb1ef78..6bd90e3c3 100644
--- a/src/containers/Dashboard/index.jsx
+++ b/src/containers/Dashboard/index.jsx
@@ -1,7 +1,7 @@
-import React from 'react';
+import React, { useMemo } from 'react';
 
-import { reduxHooks } from 'hooks';
-import { RequestKeys } from 'data/constants/requests';
+import { useSelectSessionModal } from 'data/context';
+import { useInitializeLearnerHome } from 'data/hooks';
 import SelectSessionModal from 'containers/SelectSessionModal';
 import CoursesPanel from 'containers/CoursesPanel';
 import DashboardModalSlot from 'plugin-slots/DashboardModalSlot';
@@ -12,23 +12,24 @@ import hooks from './hooks';
 import './index.scss';
 
 export const Dashboard = () => {
-  hooks.useInitializeDashboard();
+  const { data, isFetching } = useInitializeLearnerHome();
   const { pageTitle } = hooks.useDashboardMessages();
-  const hasCourses = reduxHooks.useHasCourses();
-  const initIsPending = reduxHooks.useRequestIsPending(RequestKeys.initialize);
-  const showSelectSessionModal = reduxHooks.useShowSelectSessionModal();
+  const { selectSessionModal } = useSelectSessionModal();
+  const showSelectSessionModal = selectSessionModal.cardId !== null;
+
+  const hasCourses = useMemo(() => data?.courses?.length > 0, [data]);
 
   return (
     <div id="dashboard-container" className="d-flex flex-column p-2 pt-0">
       <h1 className="sr-only">{pageTitle}</h1>
-      {!initIsPending && (
+      {!isFetching && (
         <>
           <DashboardModalSlot />
           {(hasCourses && showSelectSessionModal) && <SelectSessionModal />}
         </>
       )}
       <div id="dashboard-content" data-testid="dashboard-content">
-        {initIsPending
+        {isFetching
           ? (<LoadingView />)
           : (
             <DashboardLayout>
diff --git a/src/containers/Dashboard/index.test.jsx b/src/containers/Dashboard/index.test.jsx
index 48f03cfbe..cd1f7a96d 100644
--- a/src/containers/Dashboard/index.test.jsx
+++ b/src/containers/Dashboard/index.test.jsx
@@ -1,16 +1,17 @@
 import { render, screen } from '@testing-library/react';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
+import { useSelectSessionModal } from 'data/context';
+import { useInitializeLearnerHome } from 'data/hooks';
 
-import { reduxHooks } from 'hooks';
 import hooks from './hooks';
 import Dashboard from '.';
 
-jest.mock('hooks', () => ({
-  reduxHooks: {
-    useHasCourses: jest.fn(),
-    useShowSelectSessionModal: jest.fn(),
-    useRequestIsPending: jest.fn(),
-  },
+jest.mock('data/context', () => ({
+  useSelectSessionModal: jest.fn(),
+}));
+
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn(),
 }));
 
 jest.mock('./hooks', () => ({
@@ -34,9 +35,9 @@ describe('Dashboard', () => {
       showSelectSessionModal = true,
     } = props;
     hooks.useDashboardMessages.mockReturnValue({ pageTitle });
-    reduxHooks.useHasCourses.mockReturnValue(hasCourses);
-    reduxHooks.useRequestIsPending.mockReturnValue(initIsPending);
-    reduxHooks.useShowSelectSessionModal.mockReturnValue(showSelectSessionModal);
+    const dataMocked = { data: hasCourses ? { courses: [1, 2] } : { courses: [] }, isFetching: initIsPending };
+    useInitializeLearnerHome.mockReturnValue(dataMocked);
+    useSelectSessionModal.mockReturnValue({ selectSessionModal: showSelectSessionModal ? { cardId: 1 } : null });
     return render(<IntlProvider locale="en"><Dashboard /></IntlProvider>);
   };
 
diff --git a/src/containers/EmailSettingsModal/hooks.js b/src/containers/EmailSettingsModal/hooks.js
index 7e7397dda..37f3da65e 100644
--- a/src/containers/EmailSettingsModal/hooks.js
+++ b/src/containers/EmailSettingsModal/hooks.js
@@ -1,7 +1,8 @@
 import React from 'react';
 
 import { StrictDict } from 'utils';
-import { reduxHooks, apiHooks } from 'hooks';
+import { useUpdateEmailSettings } from 'data/hooks';
+import { useCourseData } from 'hooks';
 
 import * as module from './hooks';
 
@@ -13,12 +14,13 @@ export const useEmailData = ({
   closeModal,
   cardId,
 }) => {
-  const { hasOptedOutOfEmail } = reduxHooks.useCardEnrollmentData(cardId);
+  const courseData = useCourseData(cardId);
+  const hasOptedOutOfEmail = courseData?.enrollment?.hasOptedOutOfEmail || false;
   const [isOptedOut, setIsOptedOut] = module.state.toggle(hasOptedOutOfEmail);
-  const updateEmailSettings = apiHooks.useUpdateEmailSettings(cardId);
+  const { mutate: updateEmailSettings } = useUpdateEmailSettings();
   const onToggle = () => setIsOptedOut(!isOptedOut);
   const save = () => {
-    updateEmailSettings(!isOptedOut);
+    updateEmailSettings(cardId, !isOptedOut);
     closeModal();
   };
 
diff --git a/src/containers/EmailSettingsModal/hooks.test.js b/src/containers/EmailSettingsModal/hooks.test.js
index c70185341..aade4a953 100644
--- a/src/containers/EmailSettingsModal/hooks.test.js
+++ b/src/containers/EmailSettingsModal/hooks.test.js
@@ -1,21 +1,23 @@
 import { MockUseState } from 'testUtils';
-import { reduxHooks, apiHooks } from 'hooks';
+import { useCourseData } from 'hooks';
+import { useUpdateEmailSettings } from 'data/hooks';
 
 import * as hooks from './hooks';
 
+jest.mock('data/hooks', () => ({
+  useUpdateEmailSettings: jest.fn(),
+}));
+
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardEnrollmentData: jest.fn(),
-  },
-  apiHooks: {
-    useUpdateEmailSettings: jest.fn(),
-  },
+  useCourseData: jest.fn(() => ({
+    enrollment: {},
+  })),
 }));
 
 const cardId = 'my-test-course-number';
 const closeModal = jest.fn();
 const updateEmailSettings = jest.fn();
-apiHooks.useUpdateEmailSettings.mockReturnValue(updateEmailSettings);
+useUpdateEmailSettings.mockReturnValue({ mutate: updateEmailSettings });
 
 const state = new MockUseState(hooks);
 
@@ -30,26 +32,26 @@ describe('EmailSettingsModal hooks', () => {
   describe('useEmailData', () => {
     beforeEach(() => {
       state.mock();
-      reduxHooks.useCardEnrollmentData.mockReturnValueOnce({ hasOptedOutOfEmail: true });
+      useCourseData.mockReturnValue({ enrollment: { hasOptedOutOfEmail: true } });
       out = hooks.useEmailData({ closeModal, cardId });
     });
     afterEach(state.restore);
 
     it('loads enrollment data based on course number', () => {
-      expect(reduxHooks.useCardEnrollmentData).toHaveBeenCalledWith(cardId);
+      expect(useCourseData).toHaveBeenCalledWith(cardId);
     });
 
     it('initializes toggle value to cardData.hasOptedOutOfEmail', () => {
       state.expectInitializedWith(state.keys.toggle, true);
       expect(out.isOptedOut).toEqual(true);
 
-      reduxHooks.useCardEnrollmentData.mockReturnValueOnce({ hasOptedOutOfEmail: false });
+      useCourseData.mockReturnValueOnce({ enrollment: { hasOptedOutOfEmail: false } });
       out = hooks.useEmailData({ closeModal, cardId });
       state.expectInitializedWith(state.keys.toggle, false);
       expect(out.isOptedOut).toEqual(false);
     });
-    it('initializes email settings hok with cardId', () => {
-      expect(apiHooks.useUpdateEmailSettings).toHaveBeenCalledWith(cardId);
+    it('initializes email settings hook with cardId', () => {
+      expect(useUpdateEmailSettings).toHaveBeenCalled();
     });
     describe('onToggle - returned callback', () => {
       it('sets toggle state value to opposite current value', () => {
@@ -60,7 +62,7 @@ describe('EmailSettingsModal hooks', () => {
     describe('save', () => {
       it('calls updateEmailSettings', () => {
         out.save();
-        expect(updateEmailSettings).toHaveBeenCalledWith(!out.isOptedOut);
+        expect(updateEmailSettings).toHaveBeenCalledWith(cardId, !out.isOptedOut);
       });
       it('calls closeModal', () => {
         out.save();
diff --git a/src/containers/LearnerDashboardHeader/ConfirmEmailBanner/hooks.js b/src/containers/LearnerDashboardHeader/ConfirmEmailBanner/hooks.js
index 3797c682f..9536fa826 100644
--- a/src/containers/LearnerDashboardHeader/ConfirmEmailBanner/hooks.js
+++ b/src/containers/LearnerDashboardHeader/ConfirmEmailBanner/hooks.js
@@ -1,7 +1,7 @@
 import React from 'react';
 
 import { StrictDict } from 'utils';
-import { apiHooks, reduxHooks } from 'hooks';
+import { useInitializeLearnerHome, useSendConfirmEmail } from 'data/hooks';
 
 import * as module from './hooks';
 
@@ -11,13 +11,15 @@ export const state = StrictDict({
 });
 
 export const useConfirmEmailBannerData = () => {
-  const { isNeeded } = reduxHooks.useEmailConfirmationData();
+  const { data: learnerData } = useInitializeLearnerHome();
+  const isNeeded = learnerData?.emailConfirmation?.isNeeded || false;
+  const sendEmailUrl = learnerData?.emailConfirmation?.sendEmailUrl || '';
+  const { mutate: sendConfirmEmail } = useSendConfirmEmail(sendEmailUrl);
   const [showPageBanner, setShowPageBanner] = module.state.showPageBanner(isNeeded);
   const [showConfirmModal, setShowConfirmModal] = module.state.showConfirmModal(false);
   const closePageBanner = () => setShowPageBanner(false);
   const closeConfirmModal = () => setShowConfirmModal(false);
   const openConfirmModal = () => setShowConfirmModal(true);
-  const sendConfirmEmail = apiHooks.useSendConfirmEmail();
 
   const openConfirmModalButtonClick = () => {
     sendConfirmEmail();
diff --git a/src/containers/LearnerDashboardHeader/ConfirmEmailBanner/hooks.test.js b/src/containers/LearnerDashboardHeader/ConfirmEmailBanner/hooks.test.js
index 6d8c562ff..a0eb1665f 100644
--- a/src/containers/LearnerDashboardHeader/ConfirmEmailBanner/hooks.test.js
+++ b/src/containers/LearnerDashboardHeader/ConfirmEmailBanner/hooks.test.js
@@ -1,19 +1,16 @@
 import { MockUseState } from 'testUtils';
-import { reduxHooks, apiHooks } from 'hooks';
+import { useInitializeLearnerHome, useSendConfirmEmail } from 'data/hooks';
 
 import * as hooks from './hooks';
 
-jest.mock('hooks', () => ({
-  reduxHooks: {
-    useEmailConfirmationData: jest.fn(),
-  },
-  apiHooks: {
-    useSendConfirmEmail: jest.fn(),
-  },
+jest.mock('data/hooks', () => ({
+  ...jest.requireActual('data/hooks'),
+  useInitializeLearnerHome: jest.fn(),
+  useSendConfirmEmail: jest.fn(),
 }));
 
 const sendConfirmEmail = jest.fn();
-apiHooks.useSendConfirmEmail.mockReturnValue(sendConfirmEmail);
+useSendConfirmEmail.mockReturnValue({ mutate: sendConfirmEmail });
 
 const emailConfirmation = {
   isNeeded: true,
@@ -35,14 +32,13 @@ describe('ConfirmEmailBanner hooks', () => {
     afterEach(state.restore);
 
     test('show page banner on unverified email', () => {
-      reduxHooks.useEmailConfirmationData.mockReturnValueOnce({ ...emailConfirmation });
+      useInitializeLearnerHome.mockReturnValueOnce({ data: { emailConfirmation: { ...emailConfirmation } } });
       out = hooks.useConfirmEmailBannerData();
       expect(out.isNeeded).toEqual(emailConfirmation.isNeeded);
-      reduxHooks.useEmailConfirmationData.mockReturnValueOnce({ isNeeded: false });
     });
 
     test('hide page banner on verified email', () => {
-      reduxHooks.useEmailConfirmationData.mockReturnValueOnce({ isNeeded: false });
+      useInitializeLearnerHome.mockReturnValueOnce({ data: { emailConfirmation: { isNeeded: false } } });
       out = hooks.useConfirmEmailBannerData();
       expect(out.isNeeded).toEqual(false);
     });
@@ -51,7 +47,7 @@ describe('ConfirmEmailBanner hooks', () => {
   describe('behavior', () => {
     beforeEach(() => {
       state.mock();
-      reduxHooks.useEmailConfirmationData.mockReturnValueOnce({ ...emailConfirmation });
+      useInitializeLearnerHome.mockReturnValueOnce({ data: { emailConfirmation: { ...emailConfirmation } } });
       out = hooks.useConfirmEmailBannerData();
     });
     afterEach(state.restore);
diff --git a/src/containers/LearnerDashboardHeader/index.jsx b/src/containers/LearnerDashboardHeader/index.jsx
index 2cd167658..6f3b31d9c 100644
--- a/src/containers/LearnerDashboardHeader/index.jsx
+++ b/src/containers/LearnerDashboardHeader/index.jsx
@@ -3,7 +3,7 @@ import React from 'react';
 import MasqueradeBar from 'containers/MasqueradeBar';
 import { AppContext } from '@edx/frontend-platform/react';
 import Header from '@edx/frontend-component-header';
-import { reduxHooks } from 'hooks';
+import { useInitializeLearnerHome } from 'data/hooks';
 import urls from 'data/services/lms/urls';
 
 import ConfirmEmailBanner from './ConfirmEmailBanner';
@@ -14,7 +14,8 @@ import './index.scss';
 
 export const LearnerDashboardHeader = () => {
   const { authenticatedUser } = React.useContext(AppContext);
-  const { courseSearchUrl } = reduxHooks.usePlatformSettingsData();
+  const { data: learnerData } = useInitializeLearnerHome();
+  const courseSearchUrl = learnerData?.platformSettings?.courseSearchUrl || '';
 
   const exploreCoursesClick = () => {
     findCoursesNavClicked(urls.baseAppUrl(courseSearchUrl));
diff --git a/src/containers/LearnerDashboardHeader/index.test.jsx b/src/containers/LearnerDashboardHeader/index.test.jsx
index 6179b4526..a8cd80bea 100644
--- a/src/containers/LearnerDashboardHeader/index.test.jsx
+++ b/src/containers/LearnerDashboardHeader/index.test.jsx
@@ -8,12 +8,14 @@ import { findCoursesNavClicked } from './hooks';
 
 const courseSearchUrl = '/course-search-url';
 
-jest.mock('hooks', () => ({
-  reduxHooks: {
-    usePlatformSettingsData: jest.fn(() => ({
-      courseSearchUrl,
-    })),
-  },
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn().mockReturnValue({
+    data: {
+      platformSettings: {
+        courseSearchUrl,
+      },
+    },
+  }),
 }));
 jest.mock('./hooks', () => ({
   ...jest.requireActual('./hooks'),
diff --git a/src/containers/MasqueradeBar/hooks.js b/src/containers/MasqueradeBar/hooks.js
index 4310c2dab..88eceaa46 100644
--- a/src/containers/MasqueradeBar/hooks.js
+++ b/src/containers/MasqueradeBar/hooks.js
@@ -1,7 +1,9 @@
+// TODO: not being used
 import React from 'react';
 import { useIntl } from '@edx/frontend-platform/i18n';
 
-import { apiHooks, reduxHooks } from 'hooks';
+import { useInitializeLearnerHome } from 'data/hooks';
+import { useMasquerade } from 'data/context';
 import { StrictDict } from 'utils';
 import * as module from './hooks';
 
@@ -35,23 +37,30 @@ export const useMasqueradeBarData = ({
   authenticatedUser,
 }) => {
   const { formatMessage } = useIntl();
-  const handleMasqueradeAs = apiHooks.useMasqueradeAs();
-  const handleClearMasquerade = apiHooks.useClearMasquerade();
+  const query = useInitializeLearnerHome();
 
   const {
     isMasquerading,
-    isMasqueradingFailed,
-    isMasqueradingPending,
-    masqueradeErrorStatus,
-  } = reduxHooks.useMasqueradeData();
+    setMasqueradeUser,
+  } = useMasquerade();
+
+  const isMasqueradingPending = isMasquerading && query?.isPending;
+  const isMasqueradingFailed = isMasquerading && query?.isError;
+  const masqueradeErrorStatus = isMasquerading && query?.isError ? query?.error : null;
   const { masqueradeInput, handleMasqueradeInputChange } = module.useMasqueradeInput();
 
   const masqueradeErrorMessage = getMasqueradeErrorMessage(masqueradeErrorStatus);
+
   const handleMasqueradeSubmit = (user) => (e) => {
-    handleMasqueradeAs(user);
+    setMasqueradeUser(user);
     e.preventDefault();
   };
 
+  const handleClearMasquerade = () => {
+    setMasqueradeUser(undefined);
+    handleMasqueradeInputChange({ target: { value: '' } });
+  };
+
   return {
     canMasquerade: authenticatedUser?.administrator,
     isMasquerading,
diff --git a/src/containers/MasqueradeBar/hooks.test.js b/src/containers/MasqueradeBar/hooks.test.js
index d826f77fb..a10bbdf1a 100644
--- a/src/containers/MasqueradeBar/hooks.test.js
+++ b/src/containers/MasqueradeBar/hooks.test.js
@@ -1,9 +1,18 @@
 import { MockUseState } from 'testUtils';
-import { apiHooks, reduxHooks } from 'hooks';
+import { useInitializeLearnerHome } from 'data/hooks';
+import { useMasquerade } from 'data/context';
 
 import * as hooks from './hooks';
 import messages from './messages';
 
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn(),
+}));
+
+jest.mock('data/context/MasqueradeProvider', () => ({
+  useMasquerade: jest.fn(),
+}));
+
 jest.mock('@edx/frontend-platform/i18n', () => {
   const { formatMessage } = jest.requireActual('testUtils');
   return {
@@ -14,20 +23,7 @@ jest.mock('@edx/frontend-platform/i18n', () => {
   };
 });
 
-jest.mock('hooks', () => ({
-  apiHooks: {
-    useMasqueradeAs: jest.fn(),
-    useClearMasquerade: jest.fn(),
-  },
-  reduxHooks: {
-    useMasqueradeData: jest.fn(),
-  },
-}));
-
 const masqueradeAs = jest.fn();
-const clearMasquerade = jest.fn();
-apiHooks.useMasqueradeAs.mockReturnValue(masqueradeAs);
-apiHooks.useClearMasquerade.mockReturnValue(clearMasquerade);
 const state = new MockUseState(hooks);
 const testValue = 'test-value';
 
@@ -35,18 +31,17 @@ describe('MasqueradeBar hooks', () => {
   const authenticatedUser = {
     administrator: true,
   };
-  const defaultMasqueradeData = {
-    isMasquerading: false,
-    isMasqueradingFailed: false,
-    isMasqueradingPending: false,
-    masqueradeErrorStatus: null,
-  };
-  const createHook = (masqueradeData = {}, user = undefined) => {
-    reduxHooks.useMasqueradeData.mockReturnValueOnce({
-      ...defaultMasqueradeData,
-      ...masqueradeData,
+  const createHook = (masqueradeData = {}, user = authenticatedUser) => {
+    useInitializeLearnerHome.mockReturnValue({
+      isPending: masqueradeData.isMasqueradingPending || false,
+      isError: masqueradeData.isMasqueradingFailed || false,
+      error: masqueradeData.masqueradeErrorStatus || null,
+    });
+    useMasquerade.mockReturnValue({
+      isMasquerading: masqueradeData.isMasquerading || false,
+      setMasqueradeUser: masqueradeAs,
     });
-    return hooks.useMasqueradeBarData({ authenticatedUser: user || authenticatedUser });
+    return hooks.useMasqueradeBarData({ authenticatedUser: user });
   };
 
   describe('state values', () => {
@@ -66,13 +61,13 @@ describe('MasqueradeBar hooks', () => {
     test('masqueradeErrorStatus', () => {
       let out = createHook();
       expect(out.masqueradeErrorMessage).toBeNull();
-      out = createHook({ masqueradeErrorStatus: 0 });
+      out = createHook({ masqueradeErrorStatus: 500, isMasqueradingFailed: true, isMasquerading: true });
       expect(out.masqueradeErrorMessage).not.toBeNull();
     });
     test('isMasqueradePending', () => {
       let out = createHook();
       expect(out.isMasqueradingPending).toEqual(false);
-      out = createHook({ isMasqueradingPending: true });
+      out = createHook({ isMasqueradingPending: true, isMasquerading: true });
       expect(out.isMasqueradingPending).toEqual(true);
     });
     test('handleMasqueradeInputChange', () => {
@@ -94,7 +89,8 @@ describe('MasqueradeBar hooks', () => {
     test('handleClearMasquerade', () => {
       const out = createHook();
       out.handleClearMasquerade();
-      expect(clearMasquerade).toHaveBeenCalled();
+      expect(masqueradeAs).toHaveBeenCalledWith(undefined);
+      expect(state.setState.masqueradeInput).toHaveBeenCalledWith('');
     });
   });
 
diff --git a/src/containers/MasqueradeBar/index.jsx b/src/containers/MasqueradeBar/index.jsx
index e69b9ceb4..028ef2c51 100644
--- a/src/containers/MasqueradeBar/index.jsx
+++ b/src/containers/MasqueradeBar/index.jsx
@@ -1,4 +1,5 @@
-import React from 'react';
+import React, { useMemo } from 'react';
+import { useIntl } from '@edx/frontend-platform/i18n';
 import { AppContext } from '@edx/frontend-platform/react';
 
 import {
@@ -13,25 +14,39 @@ import {
 } from '@openedx/paragon';
 import { Close, PersonSearch } from '@openedx/paragon/icons';
 
+import { useMasquerade } from 'data/context';
+import { useInitializeLearnerHome } from 'data/hooks';
 import messages from './messages';
-import { useMasqueradeBarData } from './hooks';
 import './index.scss';
 
 export const MasqueradeBar = () => {
+  const { formatMessage } = useIntl();
+  const {
+    isError, error, isPending,
+  } = useInitializeLearnerHome();
   const { authenticatedUser } = React.useContext(AppContext);
+  const [masqueradeInput, setMasqueradeInput] = React.useState(undefined);
+  const canMasquerade = authenticatedUser?.administrator;
+  const { masqueradeUser, setMasqueradeUser } = useMasquerade();
+  const handleMasqueradeInputChange = (e) => setMasqueradeInput(e.target.value);
+  const handleClearMasquerade = () => {
+    setMasqueradeUser(undefined);
+    setMasqueradeInput(undefined);
+  };
+  const handleMasqueradeSubmit = (user) => (e) => {
+    setMasqueradeUser(user);
+    e.preventDefault();
+  };
 
-  const {
-    canMasquerade,
-    isMasquerading,
-    isMasqueradingFailed,
-    isMasqueradingPending,
-    masqueradeInput,
-    masqueradeErrorMessage,
-    handleMasqueradeInputChange,
-    handleClearMasquerade,
-    handleMasqueradeSubmit,
-    formatMessage,
-  } = useMasqueradeBarData({ authenticatedUser });
+  const isMasqueradingFailed = !!masqueradeUser && masqueradeInput && isError;
+  const isMasqueradingPending = !!masqueradeUser && isPending;
+  const isMasquerading = !!masqueradeUser && !isError && !isPending;
+  const masqueradeErrorMessage = useMemo(() => {
+    if (masqueradeUser && error) {
+      return (error.customAttributes.httpErrorStatus === 404 ? messages.NoStudentFound : messages.UnknownError);
+    }
+    return null;
+  }, [error, masqueradeUser]);
 
   if (!canMasquerade) { return null; }
 
@@ -72,7 +87,7 @@ export const MasqueradeBar = () => {
               )}
             </FormGroup>
             <StatefulButton
-              disabled={!masqueradeInput.length}
+              disabled={!masqueradeInput?.length}
               variant="brand"
               onClick={handleMasqueradeSubmit(masqueradeInput)}
               labels={{
diff --git a/src/containers/MasqueradeBar/index.test.jsx b/src/containers/MasqueradeBar/index.test.jsx
index a419aead9..6c63df1c2 100644
--- a/src/containers/MasqueradeBar/index.test.jsx
+++ b/src/containers/MasqueradeBar/index.test.jsx
@@ -1,32 +1,55 @@
+import { useContext, useState } from 'react';
 import { render, screen } from '@testing-library/react';
-import { formatMessage } from 'testUtils';
+import { IntlProvider } from '@edx/frontend-platform/i18n';
 
+import { useInitializeLearnerHome } from 'data/hooks';
+import { useMasquerade } from 'data/context';
 import MasqueradeBar from '.';
-import hooks from './hooks';
+// import hooks from './hooks';
 import messages from './messages';
 
-jest.mock('./hooks', () => ({
-  useMasqueradeBarData: jest.fn(),
+jest.mock('data/context/MasqueradeProvider', () => ({
+  useMasquerade: jest.fn(),
 }));
 
-describe('MasqueradeBar', () => {
-  const masqueradeMockData = {
-    canMasquerade: true,
-    isMasquerading: false,
-    isMasqueradingFailed: false,
-    isMasqueradingPending: false,
-    masqueradeInput: '',
-    masqueradeErrorMessage: '',
-    handleMasqueradeInputChange: jest.fn().mockName('handleMasqueradeInputChange'),
-    handleClearMasquerade: jest.fn().mockName('handleClearMasquerade'),
-    handleMasqueradeSubmit: jest.fn().mockName('handleMasqueradeSubmit'),
-    formatMessage,
+jest.mock('react', () => {
+  const ActualReact = jest.requireActual('react');
+  return {
+    ...ActualReact,
+    useState: jest.fn(ActualReact.useState),
+    useContext: jest.fn((context) => {
+      // eslint-disable-next-line global-require
+      if (context === require('@edx/frontend-platform/react').AppContext) {
+        return {
+          authenticatedUser: { administrator: true },
+        };
+      }
+      return ActualReact.useContext(context);
+    }),
   };
+});
 
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn(),
+}));
+
+const mockDefaults = () => {
+  useMasquerade.mockReturnValue({
+    masqueradeUser: null,
+    setMasqueradeUser: jest.fn(),
+  });
+  useInitializeLearnerHome.mockReturnValue({
+    isError: false,
+    error: null,
+    isPending: false,
+  });
+};
+
+describe('MasqueradeBar', () => {
   describe('render', () => {
     it('can masquerade', () => {
-      hooks.useMasqueradeBarData.mockReturnValueOnce(masqueradeMockData);
-      render(<MasqueradeBar />);
+      mockDefaults();
+      render(<IntlProvider lang="en"><MasqueradeBar /></IntlProvider>);
       const labelStudentName = screen.getByText(messages.StudentNameInput.defaultMessage);
       expect(labelStudentName).toBeInTheDocument();
       const submitButton = screen.getByRole('button', { name: messages.SubmitButton.defaultMessage });
@@ -34,56 +57,106 @@ describe('MasqueradeBar', () => {
     });
     it('can masquerade with input', () => {
       const masqueradeInput = 'test';
-      hooks.useMasqueradeBarData.mockReturnValueOnce({
-        ...masqueradeMockData,
-        masqueradeInput,
-      });
-      render(<MasqueradeBar />);
+      mockDefaults();
+      useState.mockReturnValue([masqueradeInput, jest.fn()]);
+      render(<IntlProvider lang="en"><MasqueradeBar /></IntlProvider>);
       const valueMasqueradeInput = screen.getByRole('textbox', { value: masqueradeInput });
       expect(valueMasqueradeInput).toBeInTheDocument();
     });
-    it('cannot masquerade', () => {
-      hooks.useMasqueradeBarData.mockReturnValueOnce({
-        ...masqueradeMockData,
-        canMasquerade: false,
-      });
-      render(<MasqueradeBar />);
-      const labelStudentName = screen.queryByText(messages.StudentNameInput.defaultMessage);
-      expect(labelStudentName).toBeNull();
-    });
     it('is masquerading with input', () => {
       const masqueradeInput = 'test';
-      hooks.useMasqueradeBarData.mockReturnValueOnce({
-        ...masqueradeMockData,
-        isMasquerading: true,
-        masqueradeInput,
+      useInitializeLearnerHome.mockReturnValue({
+        isError: false,
+        error: null,
+        isPending: false,
+      });
+      useMasquerade.mockReturnValue({
+        masqueradeUser: masqueradeInput,
+        setMasqueradeUser: jest.fn(),
       });
-      render(<MasqueradeBar />);
+      useState.mockReturnValue([masqueradeInput, jest.fn()]);
+      render(<IntlProvider lang="en"><MasqueradeBar /></IntlProvider>);
       const chipMasqueradeInput = screen.getByText(masqueradeInput);
       expect(chipMasqueradeInput).toBeInTheDocument();
       expect(chipMasqueradeInput.parentElement).toHaveClass('masquerade-chip');
     });
     it('is masquerading failed with error', () => {
-      const masqueradeErrorMessage = 'test-error';
       const masqueradeInput = 'test';
-      hooks.useMasqueradeBarData.mockReturnValueOnce({
-        ...masqueradeMockData,
-        isMasqueradingFailed: true,
-        masqueradeErrorMessage,
+      useInitializeLearnerHome.mockReturnValue({
+        isError: true,
+        error: { customAttributes: { httpErrorStatus: 404 } },
+        isPending: false,
       });
-      render(<MasqueradeBar />);
+      useMasquerade.mockReturnValue({
+        masqueradeUser: masqueradeInput,
+        setMasqueradeUser: jest.fn(),
+      });
+      useState.mockReturnValue([masqueradeInput, jest.fn()]);
+      render(<IntlProvider lang="en"><MasqueradeBar /></IntlProvider>);
       const valueMasqueradeInput = screen.getByRole('textbox', { value: masqueradeInput });
       expect(valueMasqueradeInput).toHaveClass('is-invalid');
     });
     it('is masquerading pending', () => {
-      hooks.useMasqueradeBarData.mockReturnValueOnce({
-        ...masqueradeMockData,
-        isMasqueradingPending: true,
+      useInitializeLearnerHome.mockReturnValue({
+        isError: false,
+        error: null,
+        isPending: true,
+      });
+      useMasquerade.mockReturnValue({
+        masqueradeUser: 'test',
+        setMasqueradeUser: jest.fn(),
       });
-      render(<MasqueradeBar />);
+      render(<IntlProvider lang="en"><MasqueradeBar /></IntlProvider>);
       const pendingButton = screen.getByRole('button', { name: messages.SubmitButton.defaultMessage });
       expect(pendingButton).toBeInTheDocument();
       expect(pendingButton).toHaveAttribute('aria-disabled', 'true');
     });
+    it('handle clear masquerade', () => {
+      const setMasqueradeUser = jest.fn();
+      const masqueradeInput = 'test';
+      useInitializeLearnerHome.mockReturnValue({
+        isError: false,
+        error: null,
+        isPending: false,
+      });
+      useMasquerade.mockReturnValue({
+        masqueradeUser: masqueradeInput,
+        setMasqueradeUser,
+      });
+      useState.mockReturnValue([masqueradeInput, jest.fn()]);
+      render(<IntlProvider lang="en"><MasqueradeBar /></IntlProvider>);
+      const chipMasqueradeInput = screen.getByText(masqueradeInput);
+      expect(chipMasqueradeInput).toBeInTheDocument();
+      chipMasqueradeInput.click();
+      expect(setMasqueradeUser).toHaveBeenCalledWith(undefined);
+    });
+    it('handle masquerade submit', () => {
+      const setMasqueradeUser = jest.fn();
+      const masqueradeInput = 'test';
+      useInitializeLearnerHome.mockReturnValue({
+        isError: false,
+        error: null,
+        isPending: false,
+      });
+      useMasquerade.mockReturnValue({
+        masqueradeUser: null,
+        setMasqueradeUser,
+      });
+      useState.mockReturnValue([masqueradeInput, jest.fn()]);
+      render(<IntlProvider lang="en"><MasqueradeBar /></IntlProvider>);
+      const submitButton = screen.getByRole('button', { name: messages.SubmitButton.defaultMessage });
+      expect(submitButton).toBeInTheDocument();
+      submitButton.click();
+      expect(setMasqueradeUser).toHaveBeenCalledWith(masqueradeInput);
+    });
+    it('cannot masquerade', () => {
+      mockDefaults();
+      useContext.mockReturnValue({
+        authenticatedUser: { administrator: false },
+      });
+      render(<IntlProvider lang="en"><MasqueradeBar /></IntlProvider>);
+      const labelStudentName = screen.queryByText(messages.StudentNameInput.defaultMessage);
+      expect(labelStudentName).toBeNull();
+    });
   });
 });
diff --git a/src/containers/RelatedProgramsModal/hooks.js b/src/containers/RelatedProgramsModal/hooks.js
deleted file mode 100644
index 5c4105dac..000000000
--- a/src/containers/RelatedProgramsModal/hooks.js
+++ /dev/null
@@ -1,10 +0,0 @@
-import { reduxHooks } from 'hooks';
-
-export const useProgramData = ({
-  cardId,
-}) => ({
-  courseTitle: reduxHooks.useCardCourseData(cardId).title,
-  relatedPrograms: reduxHooks.useCardRelatedProgramsData(cardId).list,
-});
-
-export default useProgramData;
diff --git a/src/containers/RelatedProgramsModal/index.jsx b/src/containers/RelatedProgramsModal/index.jsx
index 3d5c10d4a..112f412d0 100644
--- a/src/containers/RelatedProgramsModal/index.jsx
+++ b/src/containers/RelatedProgramsModal/index.jsx
@@ -7,7 +7,7 @@ import {
   Container, Row, Col, ModalDialog,
 } from '@openedx/paragon';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 import ProgramCard from './components/ProgramCard';
 import messages from './messages';
 import './index.scss';
@@ -18,8 +18,9 @@ export const RelatedProgramsModal = ({
   cardId,
 }) => {
   const { formatMessage } = useIntl();
-  const { courseName } = reduxHooks.useCardCourseData(cardId);
-  const relatedPrograms = reduxHooks.useCardRelatedProgramsData(cardId).list;
+  const courseData = useCourseData(cardId);
+  const courseName = courseData?.course?.courseName;
+  const relatedPrograms = courseData?.programs?.relatedPrograms || [];
   return (
     <ModalDialog
       title={formatMessage(messages.header)}
diff --git a/src/containers/RelatedProgramsModal/index.test.jsx b/src/containers/RelatedProgramsModal/index.test.jsx
index 818e5ea38..cc5c8ad66 100644
--- a/src/containers/RelatedProgramsModal/index.test.jsx
+++ b/src/containers/RelatedProgramsModal/index.test.jsx
@@ -1,16 +1,13 @@
 import { render, screen } from '@testing-library/react';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
 
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 import RelatedProgramsModal from '.';
 import messages from './messages';
 
 jest.mock('./components/ProgramCard', () => jest.fn(() => <div>ProgramCard</div>));
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardCourseData: jest.fn(),
-    useCardRelatedProgramsData: jest.fn(),
-  },
+  useCourseData: jest.fn(),
 }));
 
 const cardId = 'test-card-id';
@@ -42,13 +39,19 @@ const props = {
 
 describe('RelatedProgramsModal', () => {
   beforeEach(() => {
-    reduxHooks.useCardCourseData.mockReturnValueOnce(courseData);
-    reduxHooks.useCardRelatedProgramsData.mockReturnValueOnce(programData);
+    const mockedData = {
+      course: {
+        courseName: courseData.courseName,
+      },
+      programs: {
+        relatedPrograms: programData.list,
+      },
+    };
+    useCourseData.mockReturnValueOnce(mockedData);
   });
   it('initializes hooks with cardId', () => {
     render(<IntlProvider locale="en"><RelatedProgramsModal {...props} /></IntlProvider>);
-    expect(reduxHooks.useCardCourseData).toHaveBeenCalledWith(cardId);
-    expect(reduxHooks.useCardRelatedProgramsData).toHaveBeenCalledWith(cardId);
+    expect(useCourseData).toHaveBeenCalledWith(cardId);
   });
   describe('renders', () => {
     beforeEach(() => render(<IntlProvider locale="en"><RelatedProgramsModal {...props} /></IntlProvider>));
diff --git a/src/containers/SelectSessionModal/hooks.js b/src/containers/SelectSessionModal/hooks.js
index e0b030efd..83a435780 100644
--- a/src/containers/SelectSessionModal/hooks.js
+++ b/src/containers/SelectSessionModal/hooks.js
@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { useMemo } from 'react';
 
 import { useIntl } from '@edx/frontend-platform/i18n';
 
@@ -6,8 +6,9 @@ import { StrictDict } from 'utils';
 
 import track from 'tracking';
 
-import { reduxHooks, apiHooks } from 'hooks';
-
+import { useCourseData } from 'hooks';
+import { useDeleteEntitlementEnrollment, useUpdateEntitlementEnrollment } from 'data/hooks';
+import { useSelectSessionModal } from 'data/context';
 import { LEAVE_OPTION } from './constants';
 import messages from './messages';
 import * as module from './hooks';
@@ -18,18 +19,31 @@ export const state = StrictDict({
 
 export const useSelectSessionModalData = () => {
   const { formatMessage } = useIntl();
-
-  const selectedCardId = reduxHooks.useSelectSessionModalData().cardId;
+  const { selectSessionModal, closeSelectSessionModal: closeSessionModal } = useSelectSessionModal();
+  const selectedCardId = selectSessionModal.cardId;
+  const courseData = useCourseData(selectedCardId);
   const {
     availableSessions,
     isFulfilled,
-  } = reduxHooks.useCardEntitlementData(selectedCardId);
-  const { title: courseTitle } = reduxHooks.useCardCourseData(selectedCardId);
-  const { courseId } = reduxHooks.useCardCourseRunData(selectedCardId) || {};
-  const { isEnrolled } = reduxHooks.useCardEnrollmentData(selectedCardId);
-  const leaveEntitlementSession = apiHooks.useLeaveEntitlementSession(selectedCardId);
-  const switchEntitlementEnrollment = apiHooks.useSwitchEntitlementEnrollment(selectedCardId);
-  const newEntitlementEnrollment = apiHooks.useNewEntitlementEnrollment(selectedCardId);
+    courseTitle,
+    courseId,
+    isEnrolled,
+    uuid,
+    isRefundable,
+  } = useMemo(() => ({
+    availableSessions: courseData?.entitlement?.availableSessions || [],
+    isFulfilled: courseData?.entitlement?.isFulfilled || false,
+    courseTitle: courseData?.course?.title || courseData?.course?.courseName || '',
+    courseId: courseData?.courseRun?.courseId || null,
+    isEnrolled: courseData?.enrollment?.isEnrolled || false,
+    uuid: courseData?.entitlement?.uuid || null,
+    isRefundable: courseData?.entitlement?.isRefundable || false,
+  }), [courseData]);
+  const { mutate: leaveEntitlement } = useDeleteEntitlementEnrollment();
+  const leaveEntitlementSession = () => leaveEntitlement({ uuid, isRefundable });
+  const { mutate: switchEntitlementMutation } = useUpdateEntitlementEnrollment();
+  const switchEntitlementEnrollment = (selectedId) => switchEntitlementMutation({ uuid, courseId: selectedId });
+  const newEntitlementEnrollment = (selectedId) => switchEntitlementMutation({ uuid, courseId: selectedId });
 
   const [selectedSession, setSelectedSession] = module.state.selectedSession(courseId || null);
 
@@ -42,7 +56,6 @@ export const useSelectSessionModalData = () => {
     header = formatMessage(messages.selectSessionHeader, { courseTitle });
     hint = formatMessage(messages.selectSessionHint);
   }
-  const closeSessionModal = reduxHooks.useUpdateSelectSessionModalCallback(null);
 
   const trackNewSession = track.entitlements.newSession(selectedSession);
   const trackSwitchSession = track.entitlements.switchSession(selectedCardId, selectedSession);
diff --git a/src/containers/SelectSessionModal/hooks.test.js b/src/containers/SelectSessionModal/hooks.test.js
index b463ee94e..9433b4e1c 100644
--- a/src/containers/SelectSessionModal/hooks.test.js
+++ b/src/containers/SelectSessionModal/hooks.test.js
@@ -2,12 +2,23 @@ import { useIntl } from '@edx/frontend-platform/i18n';
 import track from 'tracking';
 
 import { MockUseState } from 'testUtils';
-import { reduxHooks, apiHooks } from 'hooks';
+import { useCourseData } from 'hooks';
+import { useDeleteEntitlementEnrollment, useUpdateEntitlementEnrollment } from 'data/hooks';
+import { useSelectSessionModal } from 'data/context';
 
 import { LEAVE_OPTION } from './constants';
 import messages from './messages';
 import * as hooks from './hooks';
 
+jest.mock('react', () => {
+  const ActualReact = jest.requireActual('react');
+  return {
+    ...ActualReact,
+    useMemo: jest.fn((fn) => fn()),
+    useState: jest.fn(),
+  };
+});
+
 jest.mock('@edx/frontend-platform/i18n', () => {
   const { formatMessage } = jest.requireActual('testUtils');
   return {
@@ -26,29 +37,23 @@ jest.mock('tracking', () => ({
   },
 }));
 jest.mock('hooks', () => ({
-  reduxHooks: {
-    useCardCourseData: jest.fn(),
-    useCardCourseRunData: jest.fn(),
-    useCardEnrollmentData: jest.fn(),
-    useCardEntitlementData: jest.fn(),
-    useSelectSessionModalData: jest.fn(),
-    useUpdateSelectSessionModalCallback: jest.fn(),
-  },
-  apiHooks: {
-    useSwitchEntitlementEnrollment: jest.fn((...args) => ({ switchEntitlementEnrollment: args })),
-    useLeaveEntitlementSession: jest.fn((...args) => ({ leaveEntitlementSession: args })),
-    useNewEntitlementEnrollment: jest.fn((...args) => ({ newEntitlementEnrollment: args })),
-  },
+  useCourseData: jest.fn(),
+}));
+
+jest.mock('data/hooks', () => ({
+  useUpdateEntitlementEnrollment: jest.fn(),
+  useDeleteEntitlementEnrollment: jest.fn(),
+}));
+
+jest.mock('data/context', () => ({
+  useSelectSessionModal: jest.fn(),
 }));
 
 const updateSelectSessionModalCallback = jest.fn();
-reduxHooks.useUpdateSelectSessionModalCallback.mockReturnValue(updateSelectSessionModalCallback);
-const newEntitlementEnrollment = jest.fn();
-apiHooks.useNewEntitlementEnrollment.mockReturnValue(newEntitlementEnrollment);
 const switchEntitlementEnrollment = jest.fn();
-apiHooks.useSwitchEntitlementEnrollment.mockReturnValue(switchEntitlementEnrollment);
+useUpdateEntitlementEnrollment.mockReturnValue({ mutate: switchEntitlementEnrollment });
 const leaveEntitlementSession = jest.fn();
-apiHooks.useLeaveEntitlementSession.mockReturnValue(leaveEntitlementSession);
+useDeleteEntitlementEnrollment.mockReturnValue({ mutate: leaveEntitlementSession });
 const trackNewSession = jest.fn();
 track.entitlements.newSession.mockReturnValue(trackNewSession);
 const trackLeaveSession = jest.fn();
@@ -74,7 +79,6 @@ const entitlementData = {
 const testValue = 'test-value';
 
 const courseId = 'test-course-id';
-reduxHooks.useCardCourseRunData.mockReturnValue({ courseId });
 
 describe('SelectSessionModal hooks', () => {
   let out;
@@ -93,11 +97,16 @@ describe('SelectSessionModal hooks', () => {
       entitlement = {},
       selectSession = {},
     }) => {
-      reduxHooks.useCardCourseData.mockReturnValueOnce({ title: courseTitle, ...course });
-      reduxHooks.useCardCourseRunData.mockReturnValueOnce({ courseId, ...courseRun });
-      reduxHooks.useCardEnrollmentData.mockReturnValueOnce({ isEnrolled: false, ...enrollment });
-      reduxHooks.useCardEntitlementData.mockReturnValueOnce({ ...entitlementData, ...entitlement });
-      reduxHooks.useSelectSessionModalData.mockReturnValueOnce({ cardId: selectedCardId, ...selectSession });
+      useCourseData.mockReturnValue({
+        course: { title: courseTitle, ...course },
+        courseRun: { courseId, ...courseRun },
+        enrollment: { isEnrolled: false, ...enrollment },
+        entitlement: { ...entitlementData, ...entitlement },
+      });
+      useSelectSessionModal.mockReturnValue({
+        selectSessionModal: { cardId: selectedCardId, ...selectSession },
+        closeSelectSessionModal: updateSelectSessionModalCallback,
+      });
       out = hooks.useSelectSessionModalData();
     };
     beforeEach(() => {
@@ -105,15 +114,8 @@ describe('SelectSessionModal hooks', () => {
       runHook({});
     });
     describe('initialization', () => {
-      it('loads redux data based on selected card id', () => {
-        expect(reduxHooks.useCardEntitlementData).toHaveBeenCalledWith(selectedCardId);
-        expect(reduxHooks.useCardCourseData).toHaveBeenCalledWith(selectedCardId);
-        expect(reduxHooks.useCardEnrollmentData).toHaveBeenCalledWith(selectedCardId);
-      });
-      it('initializes enrollment hooks with selected card id', () => {
-        expect(apiHooks.useLeaveEntitlementSession).toHaveBeenCalledWith(selectedCardId);
-        expect(apiHooks.useNewEntitlementEnrollment).toHaveBeenCalledWith(selectedCardId);
-        expect(apiHooks.useSwitchEntitlementEnrollment).toHaveBeenCalledWith(selectedCardId);
+      it('loads data based on selected card id', () => {
+        expect(useCourseData).toHaveBeenCalledWith(selectedCardId);
       });
       it('initializes selected session with courseId if available', () => {
         state.expectInitializedWith(state.keys.selectedSession, courseId);
@@ -123,7 +125,7 @@ describe('SelectSessionModal hooks', () => {
         state.expectInitializedWith(state.keys.selectedSession, null);
       });
       it('initializes update callback with null', () => {
-        expect(reduxHooks.useUpdateSelectSessionModalCallback).toHaveBeenCalledWith(null);
+        expect(useSelectSessionModal).toHaveBeenCalledWith();
       });
       it('initializes tracking methods', () => {
         expect(track.entitlements.newSession).toHaveBeenCalledWith(courseId);
@@ -155,7 +157,11 @@ describe('SelectSessionModal hooks', () => {
             state.mockVal(state.keys.selectedSession, LEAVE_OPTION);
             runHook({});
             out.handleSubmit();
-            expect(leaveEntitlementSession).toHaveBeenCalledWith();
+            const calledWith = {
+              uuid,
+              isRefundable: false,
+            };
+            expect(leaveEntitlementSession).toHaveBeenCalledWith(calledWith);
             expect(trackLeaveSession).toHaveBeenCalled();
           });
         });
@@ -164,7 +170,11 @@ describe('SelectSessionModal hooks', () => {
             state.mockVal(state.keys.selectedSession, testValue);
             runHook({});
             out.handleSubmit();
-            expect(newEntitlementEnrollment).toHaveBeenCalledWith(testValue);
+            const calledWith = {
+              courseId: testValue,
+              uuid,
+            };
+            expect(switchEntitlementEnrollment).toHaveBeenCalledWith(calledWith);
             expect(trackNewSession).toHaveBeenCalled();
           });
         });
@@ -173,7 +183,11 @@ describe('SelectSessionModal hooks', () => {
             state.mockVal(state.keys.selectedSession, testValue);
             runHook({ enrollment: { isEnrolled: true } });
             out.handleSubmit();
-            expect(switchEntitlementEnrollment).toHaveBeenCalledWith(testValue);
+            const calledWith = {
+              courseId: testValue,
+              uuid,
+            };
+            expect(switchEntitlementEnrollment).toHaveBeenCalledWith(calledWith);
             expect(trackSwitchSession).toHaveBeenCalled();
           });
         });
@@ -196,7 +210,7 @@ describe('SelectSessionModal hooks', () => {
       });
       test('closeSessionModal returns update callback wth dispatch and null card id', () => {
         expect(out.closeSessionModal()).toEqual(
-          reduxHooks.useUpdateSelectSessionModalCallback(null)(),
+          updateSelectSessionModalCallback(),
         );
       });
     });
diff --git a/src/containers/UnenrollConfirmModal/components/ConfirmPane.jsx b/src/containers/UnenrollConfirmModal/components/ConfirmPane.jsx
index 723976d1e..87be5bbf0 100644
--- a/src/containers/UnenrollConfirmModal/components/ConfirmPane.jsx
+++ b/src/containers/UnenrollConfirmModal/components/ConfirmPane.jsx
@@ -1,6 +1,6 @@
 import React from 'react';
 import PropTypes from 'prop-types';
-import { reduxHooks } from 'hooks';
+import { useCourseData } from 'hooks';
 
 import { useIntl } from '@edx/frontend-platform/i18n';
 import {
@@ -16,7 +16,8 @@ export const ConfirmPane = ({
   handleConfirm,
 }) => {
   const { formatMessage } = useIntl();
-  const { courseName } = reduxHooks.useCardCourseData(cardId);
+  const courseData = useCourseData(cardId);
+  const courseName = courseData?.course?.courseName || '';
   const courseTitle = <span className="font-italic">“{courseName}”</span>;
   return (
     <>
diff --git a/src/containers/UnenrollConfirmModal/components/ConfirmPane.test.jsx b/src/containers/UnenrollConfirmModal/components/ConfirmPane.test.jsx
index a77bbb403..18e442f76 100644
--- a/src/containers/UnenrollConfirmModal/components/ConfirmPane.test.jsx
+++ b/src/containers/UnenrollConfirmModal/components/ConfirmPane.test.jsx
@@ -1,10 +1,15 @@
 import { render, screen } from '@testing-library/react';
 import { formatMessage } from 'testUtils';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
+import { useCourseData } from 'hooks';
 
 import { ConfirmPane } from './ConfirmPane';
 import messages from './messages';
 
+jest.mock('hooks', () => ({
+  useCourseData: jest.fn(),
+}));
+
 const props = {
   cardId: 'cardId',
   handleClose: jest.fn().mockName('props.handleClose'),
@@ -14,6 +19,11 @@ const props = {
 describe('UnenrollConfirmModal ConfirmPane', () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    useCourseData.mockReturnValue({
+      course: {
+        courseName: 'Test Course',
+      },
+    });
     render(<IntlProvider locale="en"><ConfirmPane {...props} /></IntlProvider>);
   });
   it('renders title', () => {
diff --git a/src/containers/UnenrollConfirmModal/components/FinishedPane.jsx b/src/containers/UnenrollConfirmModal/components/FinishedPane.jsx
index 133fa7390..0beb6b9e8 100644
--- a/src/containers/UnenrollConfirmModal/components/FinishedPane.jsx
+++ b/src/containers/UnenrollConfirmModal/components/FinishedPane.jsx
@@ -1,7 +1,6 @@
 import React from 'react';
 import PropTypes from 'prop-types';
-import { reduxHooks } from 'hooks';
-
+import { useCourseData } from 'hooks';
 import { useIntl } from '@edx/frontend-platform/i18n';
 import {
   ActionRow,
@@ -15,7 +14,8 @@ export const FinishedPane = ({
   handleClose,
 }) => {
   const { formatMessage } = useIntl();
-  const { courseName } = reduxHooks.useCardCourseData(cardId);
+  const courseData = useCourseData(cardId);
+  const courseName = courseData?.course?.courseName || '';
   const courseTitle = <span className="font-italic">“{courseName}”</span>;
 
   return (
diff --git a/src/containers/UnenrollConfirmModal/components/FinishedPane.test.jsx b/src/containers/UnenrollConfirmModal/components/FinishedPane.test.jsx
index 02851da67..2209ba940 100644
--- a/src/containers/UnenrollConfirmModal/components/FinishedPane.test.jsx
+++ b/src/containers/UnenrollConfirmModal/components/FinishedPane.test.jsx
@@ -1,10 +1,15 @@
 import { render, screen } from '@testing-library/react';
 import { formatMessage } from 'testUtils';
 import { IntlProvider } from '@edx/frontend-platform/i18n';
+import { useCourseData } from 'hooks';
 
 import { FinishedPane } from './FinishedPane';
 import messages from './messages';
 
+jest.mock('hooks', () => ({
+  useCourseData: jest.fn(),
+}));
+
 const props = {
   cardId: 'cardId',
   handleClose: jest.fn().mockName('props.handleClose'),
@@ -14,6 +19,11 @@ describe('UnenrollConfirmModal FinishedPane', () => {
   describe('gave reason', () => {
     beforeEach(() => {
       jest.clearAllMocks();
+      useCourseData.mockReturnValue({
+        course: {
+          courseName: 'Test Course',
+        },
+      });
       render(<IntlProvider locale="en"><FinishedPane {...props} /></IntlProvider>);
     });
     it('renders heading', () => {
diff --git a/src/containers/UnenrollConfirmModal/hooks/index.js b/src/containers/UnenrollConfirmModal/hooks/index.js
index 1db099234..067e9381a 100644
--- a/src/containers/UnenrollConfirmModal/hooks/index.js
+++ b/src/containers/UnenrollConfirmModal/hooks/index.js
@@ -1,8 +1,8 @@
 import React from 'react';
 
 import { StrictDict } from 'utils';
-import { apiHooks } from 'hooks';
 
+import { useInitializeLearnerHome } from 'data/hooks';
 import { useUnenrollReasons } from './reasons';
 import * as module from '.';
 
@@ -20,7 +20,7 @@ export const useUnenrollData = ({ closeModal, cardId }) => {
   const [isConfirmed, setIsConfirmed] = module.state.confirmed(false);
   const confirm = () => setIsConfirmed(true);
   const reason = useUnenrollReasons({ cardId });
-  const refreshList = apiHooks.useInitializeApp();
+  const { refetch: refreshList } = useInitializeLearnerHome();
 
   let modalState;
   if (isConfirmed) {
diff --git a/src/containers/UnenrollConfirmModal/hooks/index.test.js b/src/containers/UnenrollConfirmModal/hooks/index.test.js
index 1db9a118e..319de8c21 100644
--- a/src/containers/UnenrollConfirmModal/hooks/index.test.js
+++ b/src/containers/UnenrollConfirmModal/hooks/index.test.js
@@ -1,6 +1,7 @@
-import { apiHooks } from 'hooks';
 import { MockUseState } from 'testUtils';
 
+import { useInitializeLearnerHome } from 'data/hooks';
+
 import * as reasons from './reasons';
 import * as hooks from '.';
 
@@ -8,16 +9,14 @@ jest.mock('./reasons', () => ({
   useUnenrollReasons: jest.fn(),
 }));
 
-jest.mock('hooks', () => ({
-  apiHooks: {
-    useInitializeApp: jest.fn(),
-  },
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn(),
 }));
 
 const state = new MockUseState(hooks);
 const testValue = 'test-value';
-const initializeApp = jest.fn();
-apiHooks.useInitializeApp.mockReturnValue(initializeApp);
+const mockRefreshList = jest.fn();
+useInitializeLearnerHome.mockReturnValue({ refetch: mockRefreshList });
 let out;
 
 const mockReason = {
@@ -76,7 +75,7 @@ describe('UnenrollConfirmModal hooks', () => {
       });
       it('calls initializeApp api method', () => {
         out.closeAndRefresh();
-        expect(initializeApp).toHaveBeenCalled();
+        expect(mockRefreshList).toHaveBeenCalled();
       });
     });
     describe('modalState', () => {
diff --git a/src/containers/UnenrollConfirmModal/hooks/reasons.js b/src/containers/UnenrollConfirmModal/hooks/reasons.js
index 9df005b4c..c9546226b 100644
--- a/src/containers/UnenrollConfirmModal/hooks/reasons.js
+++ b/src/containers/UnenrollConfirmModal/hooks/reasons.js
@@ -1,13 +1,14 @@
 import React from 'react';
 
 import {
-  apiHooks,
-  reduxHooks,
+  useCourseData,
+  useCourseTrackingEvent,
   utilHooks,
+  useEntitlementInfo,
 } from 'hooks';
 import { StrictDict } from 'utils';
 import track from 'tracking';
-
+import { useUnenrollFromCourse } from 'data/hooks';
 import * as module from './reasons';
 import constants from '../constants';
 
@@ -20,6 +21,8 @@ export const state = StrictDict({
 export const useUnenrollReasons = ({
   cardId,
 }) => {
+  const courseData = useCourseData(cardId);
+  const { mutate: unenrollFromCourseMutation } = useUnenrollFromCourse();
   // The selected option element from the menu
   const [selectedReason, setSelectedReason] = module.state.selectedReason(
     constants.reasonKeys.preferNotToSay,
@@ -30,19 +33,22 @@ export const useUnenrollReasons = ({
   // Did the user submit an unenrollment reason
   const [isSubmitted, setIsSubmitted] = module.state.isSubmitted(false);
 
-  const { isEntitlement } = reduxHooks.useCardEntitlementData(cardId);
+  const { isEntitlement } = useEntitlementInfo(courseData);
 
   const submittedReason = selectedReason === 'custom' ? customOption : selectedReason;
   const hasReason = ![null, ''].includes(submittedReason);
 
-  const handleTrackReasons = reduxHooks.useTrackCourseEvent(
+  const handleTrackReasons = useCourseTrackingEvent(
     track.engagement.unenrollReason,
     cardId,
     submittedReason,
     isEntitlement,
   );
 
-  const unenrollFromCourse = apiHooks.useUnenrollFromCourse(cardId);
+  const unenrollFromCourse = () => {
+    const courseId = courseData?.courseRun?.courseId;
+    unenrollFromCourseMutation({ courseId });
+  };
 
   const handleClear = () => {
     setSelectedReason(null);
diff --git a/src/containers/UnenrollConfirmModal/hooks/reasons.test.js b/src/containers/UnenrollConfirmModal/hooks/reasons.test.js
index 0fc9cbc99..95676ad88 100644
--- a/src/containers/UnenrollConfirmModal/hooks/reasons.test.js
+++ b/src/containers/UnenrollConfirmModal/hooks/reasons.test.js
@@ -1,22 +1,24 @@
 import { MockUseState } from 'testUtils';
 import track from 'tracking';
 import {
-  apiHooks,
-  reduxHooks,
   utilHooks,
+  useCourseTrackingEvent,
+  useCourseData,
+  useEntitlementInfo,
 } from 'hooks';
 
+import { useUnenrollFromCourse } from 'data/hooks';
 import * as hooks from './reasons';
 import constants from '../constants';
 
+jest.mock('data/hooks', () => ({
+  useUnenrollFromCourse: jest.fn(),
+}));
+
 jest.mock('hooks', () => ({
-  apiHooks: {
-    useUnenrollFromCourse: jest.fn((...args) => ({ unenrollFromCourse: args })),
-  },
-  reduxHooks: {
-    useCardEntitlementData: jest.fn(),
-    useTrackCourseEvent: jest.fn(),
-  },
+  useCourseTrackingEvent: jest.fn(),
+  useCourseData: jest.fn(),
+  useEntitlementInfo: jest.fn(),
   utilHooks: {
     useValueCallback: jest.fn((cb, prereqs) => ({ useValueCallback: { cb, prereqs } })),
   },
@@ -26,14 +28,16 @@ const state = new MockUseState(hooks);
 const testValue = 'test-value';
 const testValue2 = 'test-value2';
 const unenrollFromCourse = jest.fn((...args) => ({ unenrollFromCourse: args }));
+useUnenrollFromCourse.mockReturnValue({ mutate: unenrollFromCourse });
 const trackCourseEvent = jest.fn((e) => ({ courseEvent: e }));
-apiHooks.useUnenrollFromCourse.mockReturnValue(unenrollFromCourse);
-reduxHooks.useTrackCourseEvent.mockReturnValue(trackCourseEvent);
+useCourseTrackingEvent.mockReturnValue(trackCourseEvent);
 let out;
 
 const cardId = 'test-card-id';
+const courseData = { courseRun: { courseId: cardId } };
+useCourseData.mockReturnValue(courseData);
 const loadHook = (isEntitlement = false) => {
-  reduxHooks.useCardEntitlementData.mockReturnValue({ isEntitlement });
+  useEntitlementInfo.mockReturnValue({ isEntitlement });
   out = hooks.useUnenrollReasons({ cardId });
 };
 
@@ -69,7 +73,7 @@ describe('UnenrollConfirmModal reasons hooks', () => {
           state.mockVal(state.keys.selectedReason, 'custom');
           state.mockVal(state.keys.customOption, testValue);
           loadHook();
-          expect(reduxHooks.useTrackCourseEvent).toHaveBeenCalledWith(
+          expect(useCourseTrackingEvent).toHaveBeenCalledWith(
             track.engagement.unenrollReason,
             cardId,
             testValue,
@@ -80,7 +84,7 @@ describe('UnenrollConfirmModal reasons hooks', () => {
           state.mockVal(state.keys.selectedReason, testValue2);
           state.mockVal(state.keys.customOption, testValue);
           loadHook(true);
-          expect(reduxHooks.useTrackCourseEvent).toHaveBeenCalledWith(
+          expect(useCourseTrackingEvent).toHaveBeenCalledWith(
             track.engagement.unenrollReason,
             cardId,
             testValue2,
@@ -89,10 +93,10 @@ describe('UnenrollConfirmModal reasons hooks', () => {
         });
       });
       it('initializes card entitlement data with cardId', () => {
-        expect(reduxHooks.useCardEntitlementData).toHaveBeenCalledWith(cardId);
+        expect(useEntitlementInfo).toHaveBeenCalledWith(courseData);
       });
-      it('initializes unenerollFromCourse event with cardId', () => {
-        expect(apiHooks.useUnenrollFromCourse).toHaveBeenCalledWith(cardId);
+      it('initializes unenerollFromCourse event', () => {
+        expect(useUnenrollFromCourse).toHaveBeenCalledWith();
       });
     });
     describe('output', () => {
@@ -148,7 +152,7 @@ describe('UnenrollConfirmModal reasons hooks', () => {
           const event = { test: 'event' };
           out.handleSubmit(event);
           expect(trackCourseEvent).toHaveBeenCalledWith(event);
-          expect(unenrollFromCourse).toHaveBeenCalledWith();
+          expect(unenrollFromCourse).toHaveBeenCalledWith({ courseId: cardId });
         });
       });
       test('isSubmitted returns state value', () => {
diff --git a/src/containers/UnenrollConfirmModal/index.test.jsx b/src/containers/UnenrollConfirmModal/index.test.jsx
index f4d3260c8..a1406066b 100644
--- a/src/containers/UnenrollConfirmModal/index.test.jsx
+++ b/src/containers/UnenrollConfirmModal/index.test.jsx
@@ -2,8 +2,8 @@ import { render, screen } from '@testing-library/react';
 import { formatMessage } from 'testUtils';
 
 import { IntlProvider } from '@edx/frontend-platform/i18n';
+import { useInitializeLearnerHome } from 'data/hooks';
 import { UnenrollConfirmModal } from '.';
-
 import * as hooks from './hooks';
 import messages from './components/messages';
 
@@ -13,6 +13,13 @@ jest.mock('./hooks', () => ({
   useUnenrollData: jest.fn(),
 }));
 
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn(),
+}));
+
+const mockRefreshList = jest.fn();
+useInitializeLearnerHome.mockReturnValue({ refetch: mockRefreshList });
+
 describe('UnenrollConfirmModal component', () => {
   const hookProps = {
     confirm: jest.fn().mockName('hooks.confirm'),
diff --git a/src/data/constants/app.test.js b/src/data/constants/app.test.js
index 20c554ae0..8d036586d 100644
--- a/src/data/constants/app.test.js
+++ b/src/data/constants/app.test.js
@@ -1,5 +1,8 @@
 import * as platform from '@edx/frontend-platform';
 import * as constants from './app';
+import { requestStatuses } from './credit';
+import fileConstants, { FileTypes, downloadSingleLimit, downloadAllLimit } from './files';
+import htmlKeysConstants, { buttonStates, htmlProps } from './htmlKeys';
 
 jest.unmock('./app');
 
@@ -21,4 +24,164 @@ describe('app constants', () => {
     expect(constants.locationId).toEqual(window.location.pathname.slice(1));
     window.location = old;
   });
+
+  describe('credit constants', () => {
+    describe('requestStatuses', () => {
+      it('should have correct pending status', () => {
+        expect(requestStatuses.pending).toBe('pending');
+      });
+
+      it('should have correct approved status', () => {
+        expect(requestStatuses.approved).toBe('approved');
+      });
+
+      it('should have correct rejected status', () => {
+        expect(requestStatuses.rejected).toBe('rejected');
+      });
+
+      it('should have all expected status properties', () => {
+        const expectedStatuses = ['pending', 'approved', 'rejected'];
+        const actualStatuses = Object.keys(requestStatuses);
+
+        expect(actualStatuses).toEqual(expect.arrayContaining(expectedStatuses));
+        expect(actualStatuses).toHaveLength(expectedStatuses.length);
+      });
+
+      it('should have string values for all statuses', () => {
+        Object.values(requestStatuses).forEach(status => {
+          expect(typeof status).toBe('string');
+        });
+      });
+    });
+  });
+
+  describe('files constants', () => {
+    describe('FileTypes', () => {
+      it('should have correct file type values', () => {
+        expect(FileTypes.pdf).toBe('pdf');
+        expect(FileTypes.jpg).toBe('jpg');
+        expect(FileTypes.jpeg).toBe('jpeg');
+        expect(FileTypes.png).toBe('png');
+        expect(FileTypes.bmp).toBe('bmp');
+        expect(FileTypes.txt).toBe('txt');
+        expect(FileTypes.gif).toBe('gif');
+        expect(FileTypes.jfif).toBe('jfif');
+        expect(FileTypes.pjpeg).toBe('pjpeg');
+        expect(FileTypes.pjp).toBe('pjp');
+        expect(FileTypes.svg).toBe('svg');
+      });
+
+      it('should have all expected file types', () => {
+        const expectedTypes = ['pdf', 'jpg', 'jpeg', 'png', 'bmp', 'txt', 'gif', 'jfif', 'pjpeg', 'pjp', 'svg'];
+        const actualTypes = Object.keys(FileTypes);
+
+        expect(actualTypes).toEqual(expect.arrayContaining(expectedTypes));
+        expect(actualTypes).toHaveLength(expectedTypes.length);
+      });
+
+      it('should have string values for all file types', () => {
+        Object.values(FileTypes).forEach(fileType => {
+          expect(typeof fileType).toBe('string');
+        });
+      });
+    });
+
+    describe('download limits', () => {
+      it('should have correct downloadSingleLimit value', () => {
+        expect(downloadSingleLimit).toBe(1610612736);
+      });
+
+      it('should have correct downloadAllLimit value', () => {
+        expect(downloadAllLimit).toBe(10737418240);
+      });
+
+      it('should have downloadAllLimit greater than downloadSingleLimit', () => {
+        expect(downloadAllLimit).toBeGreaterThan(downloadSingleLimit);
+      });
+
+      it('should have numeric values for download limits', () => {
+        expect(typeof downloadSingleLimit).toBe('number');
+        expect(typeof downloadAllLimit).toBe('number');
+      });
+    });
+
+    describe('default export', () => {
+      it('should export FileTypes as default', () => {
+        expect(fileConstants).toBe(FileTypes);
+      });
+
+      it('should be the same as named export', () => {
+        expect(fileConstants).toEqual(FileTypes);
+      });
+    });
+  });
+
+  describe('htmlKeys constants', () => {
+    describe('buttonStates', () => {
+      it('should have correct button state values', () => {
+        expect(buttonStates.default).toBe('default');
+        expect(buttonStates.pending).toBe('pending');
+        expect(buttonStates.error).toBe('error');
+      });
+
+      it('should have all expected button states', () => {
+        const expectedStates = ['default', 'pending', 'error'];
+        const actualStates = Object.keys(buttonStates);
+
+        expect(actualStates).toEqual(expect.arrayContaining(expectedStates));
+        expect(actualStates).toHaveLength(expectedStates.length);
+      });
+
+      it('should have string values for all button states', () => {
+        Object.values(buttonStates).forEach(state => {
+          expect(typeof state).toBe('string');
+        });
+      });
+    });
+
+    describe('htmlProps', () => {
+      it('should have correct html property values', () => {
+        expect(htmlProps.disabled).toBe('disabled');
+        expect(htmlProps.href).toBe('href');
+        expect(htmlProps.onClick).toBe('onClick');
+        expect(htmlProps.onChange).toBe('onChange');
+        expect(htmlProps.onBlur).toBe('onBlur');
+        expect(htmlProps.size).toBe('size');
+      });
+
+      it('should have all expected html properties', () => {
+        const expectedProps = ['disabled', 'href', 'onClick', 'onChange', 'onBlur', 'size'];
+        const actualProps = Object.keys(htmlProps);
+
+        expect(actualProps).toEqual(expect.arrayContaining(expectedProps));
+        expect(actualProps).toHaveLength(expectedProps.length);
+      });
+
+      it('should have string values for all html properties', () => {
+        Object.values(htmlProps).forEach(prop => {
+          expect(typeof prop).toBe('string');
+        });
+      });
+    });
+
+    describe('default export', () => {
+      it('should export buttonStates and htmlProps in default object', () => {
+        expect(htmlKeysConstants.buttonStates).toBe(buttonStates);
+        expect(htmlKeysConstants.htmlProps).toBe(htmlProps);
+      });
+
+      it('should have both properties', () => {
+        expect(htmlKeysConstants).toHaveProperty('buttonStates');
+        expect(htmlKeysConstants).toHaveProperty('htmlProps');
+      });
+
+      it('should only have expected properties', () => {
+        const expectedKeys = ['buttonStates', 'htmlProps'];
+        const actualKeys = Object.keys(htmlKeysConstants);
+
+        expect(actualKeys).toEqual(expect.arrayContaining(expectedKeys));
+        expect(actualKeys).toHaveLength(expectedKeys.length);
+      });
+    });
+  });
 });
diff --git a/src/data/context/BackedData.test.tsx b/src/data/context/BackedData.test.tsx
new file mode 100644
index 000000000..8b3a1d943
--- /dev/null
+++ b/src/data/context/BackedData.test.tsx
@@ -0,0 +1,360 @@
+import React from 'react';
+import { renderHook, act } from '@testing-library/react';
+import { BackedDataProvider, useBackedData } from './BackedDataProvider';
+
+describe('BackedDataProvider and useBackedData', () => {
+  // eslint-disable-next-line func-names
+  const createWrapper = () => function ({ children }: { children: React.ReactNode }) {
+    return <BackedDataProvider>{children}</BackedDataProvider>;
+  };
+
+  describe('useBackedData hook', () => {
+    describe('successful usage within provider', () => {
+      it('should return initial state with undefined backUpData', () => {
+        const { result } = renderHook(() => useBackedData(), {
+          wrapper: createWrapper(),
+        });
+
+        expect(result.current.backUpData).toBeUndefined();
+        expect(typeof result.current.setBackUpData).toBe('function');
+      });
+
+      it('should update backUpData when setBackUpData is called', () => {
+        const testData = { courses: ['course1', 'course2'], user: 'testUser' };
+
+        const { result } = renderHook(() => useBackedData(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.setBackUpData(testData);
+        });
+
+        expect(result.current.backUpData).toEqual(testData);
+      });
+
+      it('should update backUpData with different data types', () => {
+        const { result } = renderHook(() => useBackedData(), {
+          wrapper: createWrapper(),
+        });
+        act(() => {
+          result.current.setBackUpData('string data');
+        });
+        expect(result.current.backUpData).toBe('string data');
+        act(() => {
+          result.current.setBackUpData(12345);
+        });
+        expect(result.current.backUpData).toBe(12345);
+        const arrayData = [1, 2, 3, 'test'];
+        act(() => {
+          result.current.setBackUpData(arrayData);
+        });
+        expect(result.current.backUpData).toEqual(arrayData);
+        const complexData = {
+          courses: [
+            { id: 1, name: 'Course 1' },
+            { id: 2, name: 'Course 2' },
+          ],
+          metadata: {
+            timestamp: '2024-01-01',
+            version: '1.0',
+          },
+        };
+        act(() => {
+          result.current.setBackUpData(complexData);
+        });
+        expect(result.current.backUpData).toEqual(complexData);
+        act(() => {
+          result.current.setBackUpData(null);
+        });
+        expect(result.current.backUpData).toBeNull();
+      });
+
+      it('should handle multiple sequential updates', () => {
+        const { result } = renderHook(() => useBackedData(), {
+          wrapper: createWrapper(),
+        });
+
+        const updates = [
+          { step: 1, data: 'first' },
+          { step: 2, data: 'second' },
+          { step: 3, data: 'third' },
+        ];
+
+        updates.forEach((update) => {
+          act(() => {
+            result.current.setBackUpData(update);
+          });
+          expect(result.current.backUpData).toEqual(update);
+        });
+      });
+
+      it('should maintain referential stability of setBackUpData function', () => {
+        const { result, rerender } = renderHook(() => useBackedData(), {
+          wrapper: createWrapper(),
+        });
+
+        const firstSetFunction = result.current.setBackUpData;
+        rerender();
+
+        const secondSetFunction = result.current.setBackUpData;
+
+        expect(firstSetFunction).toBe(secondSetFunction);
+      });
+    });
+
+    describe('error handling', () => {
+      it('should throw error when used outside of provider', () => {
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+        expect(() => {
+          renderHook(() => useBackedData());
+        }).toThrow('useBackedData must be used within a BackedDataProvider');
+
+        consoleErrorSpy.mockRestore();
+      });
+
+      it('should throw error with correct message when context is null', () => {
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+        try {
+          renderHook(() => useBackedData());
+        } catch (error) {
+          expect(error).toBeInstanceOf(Error);
+          expect((error as Error).message).toBe('useBackedData must be used within a BackedDataProvider');
+        }
+
+        consoleErrorSpy.mockRestore();
+      });
+    });
+  });
+
+  describe('BackedDataProvider', () => {
+    describe('provider functionality', () => {
+      it('should provide context to multiple children', () => {
+        const { result: result1 } = renderHook(() => useBackedData(), {
+          wrapper: createWrapper(),
+        });
+
+        const { result: result2 } = renderHook(() => useBackedData(), {
+          wrapper: createWrapper(),
+        });
+        act(() => {
+          result1.current.setBackUpData('data1');
+        });
+
+        act(() => {
+          result2.current.setBackUpData('data2');
+        });
+
+        expect(result1.current.backUpData).toBe('data1');
+        expect(result2.current.backUpData).toBe('data2');
+      });
+
+      it('should handle provider re-renders without losing state', () => {
+        const TestWrapper = ({ children, rerenderTrigger }: { children: React.ReactNode, rerenderTrigger: number }) => (
+          <BackedDataProvider>
+            <div data-testid={`rerender-${rerenderTrigger}`}>
+              {children}
+            </div>
+          </BackedDataProvider>
+        );
+
+        const { result, rerender } = renderHook(() => useBackedData(), {
+          wrapper: ({ children }) => <TestWrapper rerenderTrigger={1}>{children}</TestWrapper>,
+        });
+
+        act(() => {
+          result.current.setBackUpData('persistent data');
+        });
+
+        expect(result.current.backUpData).toBe('persistent data');
+        rerender();
+
+        expect(result.current.backUpData).toBe('persistent data');
+      });
+
+      it('should initialize with correct default state', () => {
+        const { result } = renderHook(() => useBackedData(), {
+          wrapper: createWrapper(),
+        });
+
+        expect(result.current).toEqual({
+          backUpData: undefined,
+          setBackUpData: expect.any(Function),
+        });
+      });
+    });
+
+    describe('reducer functionality', () => {
+      it('should handle SET_DATA action correctly', () => {
+        const { result } = renderHook(() => useBackedData(), {
+          wrapper: createWrapper(),
+        });
+
+        const testPayload = { test: 'data', nested: { value: 123 } };
+
+        act(() => {
+          result.current.setBackUpData(testPayload);
+        });
+
+        expect(result.current.backUpData).toEqual(testPayload);
+      });
+
+      it('should preserve state for unknown actions (defensive programming)', () => {
+        const { result } = renderHook(() => useBackedData(), {
+          wrapper: createWrapper(),
+        });
+
+        const initialData = { initial: 'state' };
+
+        act(() => {
+          result.current.setBackUpData(initialData);
+        });
+
+        expect(result.current.backUpData).toEqual(initialData);
+        expect(result.current.backUpData).toEqual(initialData);
+      });
+    });
+  });
+
+  describe('integration scenarios', () => {
+    it('should work in realistic masquerade backup data scenario', () => {
+      const { result } = renderHook(() => useBackedData(), {
+        wrapper: createWrapper(),
+      });
+      const masqueradeBackupData = {
+        courses: [
+          {
+            courseId: 'course-v1:TestX+CS101+2024',
+            courseName: 'Introduction to Computer Science',
+            enrollment: { isActive: true, mode: 'verified' },
+            progress: { completion: 0.75 },
+          },
+          {
+            courseId: 'course-v1:TestX+MATH201+2024',
+            courseName: 'Advanced Mathematics',
+            enrollment: { isActive: true, mode: 'audit' },
+            progress: { completion: 0.45 },
+          },
+        ],
+        userInfo: {
+          username: 'masqueraded.user',
+          email: 'user@example.com',
+          isActive: true,
+        },
+        metadata: {
+          fetchedAt: '2024-01-15T10:30:00Z',
+          source: 'masquerade',
+        },
+      };
+
+      act(() => {
+        result.current.setBackUpData(masqueradeBackupData);
+      });
+
+      expect(result.current.backUpData).toEqual(masqueradeBackupData);
+      expect(result.current.backUpData.courses).toHaveLength(2);
+      expect(result.current.backUpData.userInfo.username).toBe('masqueraded.user');
+      expect(result.current.backUpData.metadata.source).toBe('masquerade');
+    });
+
+    it('should handle backup data clearing (reset scenario)', () => {
+      const { result } = renderHook(() => useBackedData(), {
+        wrapper: createWrapper(),
+      });
+
+      const initialData = { courses: ['course1', 'course2'] };
+      act(() => {
+        result.current.setBackUpData(initialData);
+      });
+      expect(result.current.backUpData).toEqual(initialData);
+
+      act(() => {
+        result.current.setBackUpData(null);
+      });
+      expect(result.current.backUpData).toBeNull();
+
+      act(() => {
+        result.current.setBackUpData(undefined);
+      });
+      expect(result.current.backUpData).toBeUndefined();
+    });
+
+    it('should handle concurrent updates correctly', () => {
+      const { result } = renderHook(() => useBackedData(), {
+        wrapper: createWrapper(),
+      });
+
+      const updates = [
+        { id: 1, data: 'first update' },
+        { id: 2, data: 'second update' },
+        { id: 3, data: 'third update' },
+      ];
+
+      act(() => {
+        updates.forEach(update => {
+          result.current.setBackUpData(update);
+        });
+      });
+
+      expect(result.current.backUpData).toEqual(updates[2]);
+    });
+  });
+
+  describe('TypeScript type safety', () => {
+    it('should maintain type safety for backUpData', () => {
+      const { result } = renderHook(() => useBackedData(), {
+        wrapper: createWrapper(),
+      });
+      const stringData = 'test string';
+      const numberData = 42;
+      const objectData = { key: 'value' };
+      const arrayData = [1, 2, 3];
+
+      act(() => {
+        result.current.setBackUpData(stringData);
+      });
+      expect(result.current.backUpData).toBe(stringData);
+
+      act(() => {
+        result.current.setBackUpData(numberData);
+      });
+      expect(result.current.backUpData).toBe(numberData);
+
+      act(() => {
+        result.current.setBackUpData(objectData);
+      });
+      expect(result.current.backUpData).toEqual(objectData);
+
+      act(() => {
+        result.current.setBackUpData(arrayData);
+      });
+      expect(result.current.backUpData).toEqual(arrayData);
+    });
+
+    it('should provide correct function signature for setBackUpData', () => {
+      const { result } = renderHook(() => useBackedData(), {
+        wrapper: createWrapper(),
+      });
+
+      expect(typeof result.current.setBackUpData).toBe('function');
+      expect(result.current.setBackUpData.length).toBe(1);
+    });
+  });
+
+  describe('performance considerations', () => {
+    it('should memoize context value correctly', () => {
+      const { result, rerender } = renderHook(() => useBackedData(), {
+        wrapper: createWrapper(),
+      });
+
+      const firstContextValue = {
+        backUpData: result.current.backUpData,
+        setBackUpData: result.current.setBackUpData,
+      };
+      rerender();
+      expect(result.current.setBackUpData).toBe(firstContextValue.setBackUpData);
+    });
+  });
+});
diff --git a/src/data/context/BackedDataProvider.tsx b/src/data/context/BackedDataProvider.tsx
new file mode 100644
index 000000000..47b7b7be4
--- /dev/null
+++ b/src/data/context/BackedDataProvider.tsx
@@ -0,0 +1,65 @@
+import React, {
+  createContext, useContext, useMemo, useReducer, ReactNode,
+  useCallback,
+} from 'react';
+
+interface BackedDataContextType {
+  backUpData: any;
+  setBackUpData: (backUpData: any) => void;
+}
+
+const BackedDataContext = createContext<BackedDataContextType | null>(null);
+
+interface BackedDataState {
+  backUpData: any;
+}
+
+const initialState: BackedDataState = {
+  backUpData: undefined,
+};
+
+type BackedDataAction = { type: 'SET_DATA'; payload: any };
+
+const backedDataReducer = (state: BackedDataState, action: BackedDataAction): BackedDataState => {
+  switch (action.type) {
+    case 'SET_DATA':
+      return {
+        ...state,
+        backUpData: action.payload,
+      };
+    /* istanbul ignore next */
+    default:
+      return state;
+  }
+};
+
+interface BackedDataProviderProps {
+  children: ReactNode;
+}
+
+export const BackedDataProvider: React.FC<BackedDataProviderProps> = ({ children }) => {
+  const [state, dispatch] = useReducer(backedDataReducer, initialState);
+
+  const setBackUpData = useCallback((backUpData: any) => {
+    dispatch({ type: 'SET_DATA', payload: backUpData });
+  }, []);
+
+  const contextValue = useMemo(() => ({
+    backUpData: state.backUpData,
+    setBackUpData,
+  }), [setBackUpData, state.backUpData]);
+
+  return (
+    <BackedDataContext.Provider value={contextValue}>
+      {children}
+    </BackedDataContext.Provider>
+  );
+};
+
+export const useBackedData = (): BackedDataContextType => {
+  const context = useContext(BackedDataContext);
+  if (!context) {
+    throw new Error('useBackedData must be used within a BackedDataProvider');
+  }
+  return context;
+};
diff --git a/src/data/context/Filters.test.tsx b/src/data/context/Filters.test.tsx
new file mode 100644
index 000000000..f2f301c3b
--- /dev/null
+++ b/src/data/context/Filters.test.tsx
@@ -0,0 +1,772 @@
+import React from 'react';
+import { renderHook, act } from '@testing-library/react';
+import { FiltersProvider, useFilters } from './FiltersProvider';
+
+describe('FiltersProvider and useFilters', () => {
+  // eslint-disable-next-line func-names
+  const createWrapper = () => function ({ children }: { children: React.ReactNode }) {
+    return <FiltersProvider>{children}</FiltersProvider>;
+  };
+
+  describe('useFilters hook', () => {
+    describe('initial state', () => {
+      it('should return initial filters state', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        expect(result.current.filters).toEqual([]);
+        expect(result.current.sortBy).toBe('enrolled');
+        expect(result.current.pageNumber).toBe(1);
+        expect(typeof result.current.setFilters).toBe('function');
+        expect(typeof result.current.addFilter).toBe('function');
+        expect(typeof result.current.removeFilter).toBe('function');
+        expect(typeof result.current.clearFilters).toBe('function');
+        expect(typeof result.current.setSortBy).toBe('function');
+        expect(typeof result.current.setPageNumber).toBe('function');
+      });
+
+      it('should have all expected properties in context', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        const expectedProperties = [
+          'filters',
+          'sortBy',
+          'pageNumber',
+          'setFilters',
+          'addFilter',
+          'removeFilter',
+          'clearFilters',
+          'setSortBy',
+          'setPageNumber',
+        ];
+
+        expectedProperties.forEach(prop => {
+          expect(result.current).toHaveProperty(prop);
+        });
+      });
+    });
+
+    describe('error handling', () => {
+      it('should throw error when used outside of provider', () => {
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+        expect(() => {
+          renderHook(() => useFilters());
+        }).toThrow('useFilters must be used within a FiltersProvider');
+
+        consoleErrorSpy.mockRestore();
+      });
+
+      it('should throw error with correct message when context is null', () => {
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+        try {
+          renderHook(() => useFilters());
+        } catch (error) {
+          expect(error).toBeInstanceOf(Error);
+          expect((error as Error).message).toBe('useFilters must be used within a FiltersProvider');
+        }
+
+        consoleErrorSpy.mockRestore();
+      });
+    });
+  });
+
+  describe('filters management', () => {
+    describe('setFilters', () => {
+      it('should set filters correctly', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        const testFilters = ['inProgress', 'upgraded'];
+
+        act(() => {
+          result.current.setFilters(testFilters);
+        });
+
+        expect(result.current.filters).toEqual(testFilters);
+      });
+
+      it('should handle single filter', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.setFilters(['notStarted']);
+        });
+
+        expect(result.current.filters).toEqual(['notStarted']);
+      });
+
+      it('should handle empty filters array', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+        act(() => {
+          result.current.setFilters(['inProgress', 'done']);
+        });
+        act(() => {
+          result.current.setFilters([]);
+        });
+
+        expect(result.current.filters).toEqual([]);
+      });
+
+      it('should replace existing filters completely', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.setFilters(['inProgress']);
+        });
+
+        act(() => {
+          result.current.setFilters(['done', 'upgraded']);
+        });
+
+        expect(result.current.filters).toEqual(['done', 'upgraded']);
+      });
+
+      it('should handle multiple filter types', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        const multipleFilters = [
+          'inProgress',
+          'notStarted',
+          'done',
+          'upgraded',
+          'notEnrolled',
+        ];
+
+        act(() => {
+          result.current.setFilters(multipleFilters);
+        });
+
+        expect(result.current.filters).toEqual(multipleFilters);
+      });
+    });
+
+    describe('addFilter', () => {
+      it('should add filter to empty filters array', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.addFilter('inProgress');
+        });
+
+        expect(result.current.filters).toEqual(['inProgress']);
+      });
+
+      it('should add filter to existing filters', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.setFilters(['inProgress']);
+        });
+
+        act(() => {
+          result.current.addFilter('upgraded');
+        });
+
+        expect(result.current.filters).toEqual(['inProgress', 'upgraded']);
+      });
+
+      it('should add duplicate filters (no deduplication)', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.addFilter('inProgress');
+        });
+
+        act(() => {
+          result.current.addFilter('inProgress');
+        });
+
+        expect(result.current.filters).toEqual(['inProgress', 'inProgress']);
+      });
+
+      it('should add multiple filters sequentially', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        const filtersToAdd = ['inProgress', 'upgraded', 'done'];
+
+        filtersToAdd.forEach((filter, index) => {
+          act(() => {
+            result.current.addFilter(filter);
+          });
+          expect(result.current.filters).toHaveLength(index + 1);
+          expect(result.current.filters).toContain(filter);
+        });
+
+        expect(result.current.filters).toEqual(filtersToAdd);
+      });
+    });
+
+    describe('removeFilter', () => {
+      it('should remove specific filter from filters array', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.setFilters(['inProgress', 'upgraded', 'done']);
+        });
+
+        act(() => {
+          result.current.removeFilter('upgraded');
+        });
+
+        expect(result.current.filters).toEqual(['inProgress', 'done']);
+      });
+
+      it('should handle removing non-existent filter', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.setFilters(['inProgress', 'upgraded']);
+        });
+
+        act(() => {
+          result.current.removeFilter('nonExistent');
+        });
+
+        expect(result.current.filters).toEqual(['inProgress', 'upgraded']);
+      });
+
+      it('should remove filter from empty array', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.removeFilter('inProgress');
+        });
+
+        expect(result.current.filters).toEqual([]);
+      });
+
+      it('should remove last filter leaving empty array', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.setFilters(['inProgress']);
+        });
+
+        act(() => {
+          result.current.removeFilter('inProgress');
+        });
+
+        expect(result.current.filters).toEqual([]);
+      });
+    });
+
+    describe('clearFilters', () => {
+      it('should clear all filters', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.setFilters(['inProgress', 'upgraded', 'done']);
+        });
+
+        act(() => {
+          result.current.clearFilters();
+        });
+
+        expect(result.current.filters).toEqual([]);
+      });
+
+      it('should clear filters when already empty', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.clearFilters();
+        });
+
+        expect(result.current.filters).toEqual([]);
+      });
+
+      it('should not affect sortBy and pageNumber when clearing filters', () => {
+        const { result } = renderHook(() => useFilters(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.setFilters(['inProgress']);
+          result.current.setSortBy('title');
+          result.current.setPageNumber(3);
+        });
+
+        act(() => {
+          result.current.clearFilters();
+        });
+
+        expect(result.current.filters).toEqual([]);
+        expect(result.current.sortBy).toBe('title');
+        expect(result.current.pageNumber).toBe(3);
+      });
+    });
+  });
+
+  describe('sortBy management', () => {
+    it('should have initial sortBy as "enrolled"', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      expect(result.current.sortBy).toBe('enrolled');
+    });
+
+    it('should set sortBy to "title"', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.setSortBy('title');
+      });
+
+      expect(result.current.sortBy).toBe('title');
+    });
+
+    it('should set sortBy to "enrolled"', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.setSortBy('title');
+      });
+
+      act(() => {
+        result.current.setSortBy('enrolled');
+      });
+
+      expect(result.current.sortBy).toBe('enrolled');
+    });
+
+    it('should change sortBy options multiple times', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      const sortSequence = ['title', 'enrolled', 'title', 'enrolled'] as const;
+
+      sortSequence.forEach(sortOption => {
+        act(() => {
+          result.current.setSortBy(sortOption);
+        });
+        expect(result.current.sortBy).toBe(sortOption);
+      });
+    });
+  });
+
+  describe('pageNumber management', () => {
+    it('should have initial pageNumber as 1', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      expect(result.current.pageNumber).toBe(1);
+    });
+
+    it('should set pageNumber correctly', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.setPageNumber(5);
+      });
+
+      expect(result.current.pageNumber).toBe(5);
+    });
+
+    it('should handle zero and negative page numbers', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.setPageNumber(0);
+      });
+      expect(result.current.pageNumber).toBe(0);
+
+      act(() => {
+        result.current.setPageNumber(-1);
+      });
+      expect(result.current.pageNumber).toBe(-1);
+    });
+
+    it('should handle large page numbers', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.setPageNumber(999999);
+      });
+
+      expect(result.current.pageNumber).toBe(999999);
+    });
+
+    it('should change pageNumber multiple times', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      const pageSequence = [2, 10, 1, 5, 3];
+
+      pageSequence.forEach(page => {
+        act(() => {
+          result.current.setPageNumber(page);
+        });
+        expect(result.current.pageNumber).toBe(page);
+      });
+    });
+  });
+
+  describe('reducer functionality', () => {
+    it('should handle SET_FILTERS action correctly', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      const testFilters = ['filter1', 'filter2'];
+
+      act(() => {
+        result.current.setFilters(testFilters);
+      });
+
+      expect(result.current.filters).toEqual(testFilters);
+    });
+
+    it('should handle ADD_FILTER action correctly', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.addFilter('testFilter');
+      });
+
+      expect(result.current.filters).toEqual(['testFilter']);
+    });
+
+    it('should handle REMOVE_FILTER action correctly', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.setFilters(['filter1', 'filter2', 'filter3']);
+      });
+
+      act(() => {
+        result.current.removeFilter('filter2');
+      });
+
+      expect(result.current.filters).toEqual(['filter1', 'filter3']);
+    });
+
+    it('should handle CLEAR_FILTERS action correctly', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.setFilters(['filter1', 'filter2']);
+      });
+
+      act(() => {
+        result.current.clearFilters();
+      });
+
+      expect(result.current.filters).toEqual([]);
+    });
+
+    it('should handle SET_SORT_BY action correctly', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.setSortBy('title');
+      });
+
+      expect(result.current.sortBy).toBe('title');
+    });
+
+    it('should handle SET_PAGE_NUMBER action correctly', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.setPageNumber(10);
+      });
+
+      expect(result.current.pageNumber).toBe(10);
+    });
+  });
+
+  describe('integration scenarios', () => {
+    it('should handle complete state management workflow', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+      expect(result.current.filters).toEqual([]);
+      expect(result.current.sortBy).toBe('enrolled');
+      expect(result.current.pageNumber).toBe(1);
+      act(() => {
+        result.current.addFilter('inProgress');
+        result.current.addFilter('upgraded');
+      });
+      expect(result.current.filters).toEqual(['inProgress', 'upgraded']);
+      act(() => {
+        result.current.setSortBy('title');
+        result.current.setPageNumber(2);
+      });
+      expect(result.current.sortBy).toBe('title');
+      expect(result.current.pageNumber).toBe(2);
+      act(() => {
+        result.current.removeFilter('inProgress');
+      });
+      expect(result.current.filters).toEqual(['upgraded']);
+      act(() => {
+        result.current.setFilters(['done', 'notEnrolled']);
+      });
+      expect(result.current.filters).toEqual(['done', 'notEnrolled']);
+      act(() => {
+        result.current.clearFilters();
+      });
+      expect(result.current.filters).toEqual([]);
+      expect(result.current.sortBy).toBe('title');
+      expect(result.current.pageNumber).toBe(2);
+    });
+
+    it('should handle realistic course filtering workflow', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+      expect(result.current.pageNumber).toBe(1);
+      act(() => {
+        result.current.addFilter('inProgress');
+      });
+      expect(result.current.filters).toContain('inProgress');
+      act(() => {
+        result.current.addFilter('upgraded');
+      });
+      expect(result.current.filters).toEqual(['inProgress', 'upgraded']);
+      act(() => {
+        result.current.setSortBy('title');
+      });
+      expect(result.current.sortBy).toBe('title');
+      act(() => {
+        result.current.setPageNumber(2);
+      });
+      expect(result.current.pageNumber).toBe(2);
+      act(() => {
+        result.current.removeFilter('inProgress');
+      });
+      expect(result.current.filters).toEqual(['upgraded']);
+      act(() => {
+        result.current.clearFilters();
+      });
+      expect(result.current.filters).toEqual([]);
+      expect(result.current.sortBy).toBe('title');
+      expect(result.current.pageNumber).toBe(2);
+    });
+
+    it('should handle multiple providers independently', () => {
+      const wrapper1 = createWrapper();
+      const wrapper2 = createWrapper();
+
+      const { result: result1 } = renderHook(() => useFilters(), { wrapper: wrapper1 });
+      const { result: result2 } = renderHook(() => useFilters(), { wrapper: wrapper2 });
+      act(() => {
+        result1.current.addFilter('filter1');
+        result1.current.setSortBy('title');
+        result1.current.setPageNumber(3);
+      });
+
+      act(() => {
+        result2.current.addFilter('filter2');
+        result2.current.setSortBy('enrolled');
+        result2.current.setPageNumber(5);
+      });
+      expect(result1.current.filters).toEqual(['filter1']);
+      expect(result1.current.sortBy).toBe('title');
+      expect(result1.current.pageNumber).toBe(3);
+
+      expect(result2.current.filters).toEqual(['filter2']);
+      expect(result2.current.sortBy).toBe('enrolled');
+      expect(result2.current.pageNumber).toBe(5);
+    });
+  });
+
+  describe('provider functionality', () => {
+    it('should provide context value correctly', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      expect(result.current).toBeDefined();
+      expect(result.current.filters).toBeDefined();
+      expect(result.current.sortBy).toBeDefined();
+      expect(result.current.pageNumber).toBeDefined();
+      expect(typeof result.current.setFilters).toBe('function');
+      expect(typeof result.current.addFilter).toBe('function');
+      expect(typeof result.current.removeFilter).toBe('function');
+      expect(typeof result.current.clearFilters).toBe('function');
+      expect(typeof result.current.setSortBy).toBe('function');
+      expect(typeof result.current.setPageNumber).toBe('function');
+    });
+
+    it('should handle provider re-renders without losing state', () => {
+      const TestWrapper = ({ rerenderTrigger, children }: { rerenderTrigger: number; children: React.ReactNode }) => (
+        <FiltersProvider>
+          <div data-testid={`rerender-${rerenderTrigger}`}>
+            {children}
+          </div>
+        </FiltersProvider>
+      );
+
+      const { result, rerender } = renderHook(() => useFilters(), {
+        wrapper: ({ children }) => <TestWrapper rerenderTrigger={1}>{children}</TestWrapper>,
+      });
+
+      act(() => {
+        result.current.setFilters(['persistentFilter']);
+        result.current.setSortBy('title');
+        result.current.setPageNumber(5);
+      });
+
+      rerender({ rerenderTrigger: 2 });
+      expect(result.current.filters).toEqual(['persistentFilter']);
+      expect(result.current.sortBy).toBe('title');
+      expect(result.current.pageNumber).toBe(5);
+    });
+
+    it('should maintain function referential stability', () => {
+      const { result, rerender } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      const initialFunctions = {
+        setFilters: result.current.setFilters,
+        addFilter: result.current.addFilter,
+        removeFilter: result.current.removeFilter,
+        clearFilters: result.current.clearFilters,
+        setSortBy: result.current.setSortBy,
+        setPageNumber: result.current.setPageNumber,
+      };
+      rerender();
+
+      expect(result.current.setFilters).toBe(initialFunctions.setFilters);
+      expect(result.current.addFilter).toBe(initialFunctions.addFilter);
+      expect(result.current.removeFilter).toBe(initialFunctions.removeFilter);
+      expect(result.current.clearFilters).toBe(initialFunctions.clearFilters);
+      expect(result.current.setSortBy).toBe(initialFunctions.setSortBy);
+      expect(result.current.setPageNumber).toBe(initialFunctions.setPageNumber);
+    });
+  });
+
+  describe('memoization behavior', () => {
+    it('should memoize context value when state does not change', () => {
+      const { result, rerender } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      const firstContextValue = result.current;
+      rerender();
+      expect(result.current.setFilters).toBe(firstContextValue.setFilters);
+      expect(result.current.addFilter).toBe(firstContextValue.addFilter);
+      expect(result.current.removeFilter).toBe(firstContextValue.removeFilter);
+      expect(result.current.clearFilters).toBe(firstContextValue.clearFilters);
+      expect(result.current.setSortBy).toBe(firstContextValue.setSortBy);
+      expect(result.current.setPageNumber).toBe(firstContextValue.setPageNumber);
+    });
+
+    it('should update memoized value when state changes', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      const initialValue = result.current;
+
+      act(() => {
+        result.current.addFilter('newFilter');
+      });
+      expect(result.current.filters).not.toEqual(initialValue.filters);
+      expect(result.current.filters).toContain('newFilter');
+    });
+  });
+
+  describe('edge cases and type safety', () => {
+    it('should handle empty string filters', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.addFilter('');
+      });
+
+      expect(result.current.filters).toEqual(['']);
+    });
+
+    it('should handle special character filters', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+
+      const specialFilters = ['filter-with-dash', 'filter_with_underscore', 'filter with space', 'filter!@#$%'];
+
+      specialFilters.forEach(filter => {
+        act(() => {
+          result.current.addFilter(filter);
+        });
+      });
+
+      expect(result.current.filters).toEqual(specialFilters);
+    });
+
+    it('should maintain type safety for SortOption', () => {
+      const { result } = renderHook(() => useFilters(), {
+        wrapper: createWrapper(),
+      });
+      const validSortOptions: Array<'enrolled' | 'title'> = ['enrolled', 'title'];
+
+      validSortOptions.forEach(option => {
+        act(() => {
+          result.current.setSortBy(option);
+        });
+        expect(result.current.sortBy).toBe(option);
+      });
+    });
+  });
+});
diff --git a/src/data/context/FiltersProvider.tsx b/src/data/context/FiltersProvider.tsx
new file mode 100644
index 000000000..1d61e4e18
--- /dev/null
+++ b/src/data/context/FiltersProvider.tsx
@@ -0,0 +1,105 @@
+import React, {
+  createContext, useContext, useReducer, useMemo,
+} from 'react';
+
+type SortOption = 'enrolled' | 'title';
+
+interface FiltersContextType {
+  filters: string[];
+  sortBy: SortOption;
+  pageNumber: number;
+  setFilters: (newFilters: string[]) => void;
+  addFilter: (filter: string) => void;
+  removeFilter: (filter: string) => void;
+  clearFilters: () => void;
+  setSortBy: (sortBy: SortOption) => void;
+  setPageNumber: (pageNumber: number) => void;
+}
+
+const FiltersContext = createContext<FiltersContextType | null>(null);
+
+interface FiltersState {
+  filters: string[];
+  sortBy: SortOption;
+  pageNumber: number;
+}
+
+const initialState: FiltersState = {
+  filters: [],
+  sortBy: 'enrolled',
+  pageNumber: 1,
+};
+
+const filtersReducer = (state: FiltersState, action: any): FiltersState => {
+  switch (action.type) {
+    case 'SET_FILTERS':
+      return { ...state, filters: action.payload };
+    case 'ADD_FILTER':
+      return { ...state, filters: [...state.filters, action.payload] };
+    case 'REMOVE_FILTER':
+      return { ...state, filters: state.filters.filter(item => item !== action.payload) };
+    case 'CLEAR_FILTERS':
+      return { ...state, filters: [] };
+    case 'SET_SORT_BY':
+      return { ...state, sortBy: action.payload };
+    case 'SET_PAGE_NUMBER':
+      return { ...state, pageNumber: action.payload };
+    /* istanbul ignore next */
+    default:
+      return state;
+  }
+};
+
+export const FiltersProvider = ({ children }: { children: React.ReactNode }) => {
+  const [state, dispatch] = useReducer(filtersReducer, initialState);
+
+  const setFilters = (newFilters: string[]) => {
+    dispatch({ type: 'SET_FILTERS', payload: newFilters });
+  };
+
+  const addFilter = (filter: string) => {
+    dispatch({ type: 'ADD_FILTER', payload: filter });
+  };
+
+  const removeFilter = (filter: string) => {
+    dispatch({ type: 'REMOVE_FILTER', payload: filter });
+  };
+
+  const clearFilters = () => {
+    dispatch({ type: 'CLEAR_FILTERS' });
+  };
+
+  const setSortBy = (sortOption?: SortOption) => {
+    dispatch({ type: 'SET_SORT_BY', payload: sortOption });
+  };
+
+  const setPageNumber = (pageNumber: number) => {
+    dispatch({ type: 'SET_PAGE_NUMBER', payload: pageNumber });
+  };
+
+  const contextValue = useMemo(() => ({
+    filters: state.filters,
+    sortBy: state.sortBy,
+    pageNumber: state.pageNumber,
+    setFilters,
+    addFilter,
+    removeFilter,
+    clearFilters,
+    setSortBy,
+    setPageNumber,
+  }), [state.filters, state.sortBy, state.pageNumber]);
+
+  return (
+    <FiltersContext.Provider value={contextValue}>
+      {children}
+    </FiltersContext.Provider>
+  );
+};
+
+export const useFilters = () => {
+  const context = useContext(FiltersContext);
+  if (!context) {
+    throw new Error('useFilters must be used within a FiltersProvider');
+  }
+  return context;
+};
diff --git a/src/data/context/Masquerade.test.tsx b/src/data/context/Masquerade.test.tsx
new file mode 100644
index 000000000..1f74aa562
--- /dev/null
+++ b/src/data/context/Masquerade.test.tsx
@@ -0,0 +1,580 @@
+import React from 'react';
+import { renderHook, act } from '@testing-library/react';
+import { MasqueradeProvider, useMasquerade } from './MasqueradeProvider';
+
+describe('MasqueradeProvider and useMasquerade', () => {
+  // eslint-disable-next-line func-names
+  const createWrapper = () => function ({ children }: { children: React.ReactNode }) {
+    return <MasqueradeProvider>{children}</MasqueradeProvider>;
+  };
+
+  describe('useMasquerade hook', () => {
+    describe('initial state', () => {
+      it('should return initial masquerade state', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+
+        expect(result.current.masqueradeUser).toBeUndefined();
+        expect(typeof result.current.setMasqueradeUser).toBe('function');
+      });
+
+      it('should have expected properties in context', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+
+        const expectedProperties = ['masqueradeUser', 'setMasqueradeUser'];
+
+        expectedProperties.forEach(prop => {
+          expect(result.current).toHaveProperty(prop);
+        });
+      });
+    });
+
+    describe('error handling', () => {
+      it('should throw error when used outside of provider', () => {
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+        expect(() => {
+          renderHook(() => useMasquerade());
+        }).toThrow('useMasquerade must be used within a MasqueradeProvider');
+
+        consoleErrorSpy.mockRestore();
+      });
+
+      it('should throw error with correct message when context is null', () => {
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+        try {
+          renderHook(() => useMasquerade());
+        } catch (error) {
+          expect(error).toBeInstanceOf(Error);
+          expect((error as Error).message).toBe('useMasquerade must be used within a MasqueradeProvider');
+        }
+
+        consoleErrorSpy.mockRestore();
+      });
+    });
+  });
+
+  describe('masquerade user management', () => {
+    describe('setMasqueradeUser', () => {
+      it('should set masquerade user to string value', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+
+        const testUser = 'test-user@example.com';
+
+        act(() => {
+          result.current.setMasqueradeUser(testUser);
+        });
+
+        expect(result.current.masqueradeUser).toBe(testUser);
+      });
+
+      it('should set masquerade user to undefined', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.setMasqueradeUser('initial-user');
+        });
+
+        act(() => {
+          result.current.setMasqueradeUser(undefined);
+        });
+
+        expect(result.current.masqueradeUser).toBeUndefined();
+      });
+
+      it('should handle email format users', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+
+        const emailUser = 'student@university.edu';
+
+        act(() => {
+          result.current.setMasqueradeUser(emailUser);
+        });
+
+        expect(result.current.masqueradeUser).toBe(emailUser);
+      });
+
+      it('should handle username format users', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+
+        const usernameUser = 'student123';
+
+        act(() => {
+          result.current.setMasqueradeUser(usernameUser);
+        });
+
+        expect(result.current.masqueradeUser).toBe(usernameUser);
+      });
+
+      it('should handle empty string users', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.setMasqueradeUser('');
+        });
+
+        expect(result.current.masqueradeUser).toBe('');
+      });
+
+      it('should handle users with special characters', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+
+        const specialUser = 'user.name+tag@domain-name.co.uk';
+
+        act(() => {
+          result.current.setMasqueradeUser(specialUser);
+        });
+
+        expect(result.current.masqueradeUser).toBe(specialUser);
+      });
+
+      it('should replace existing masquerade user', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.setMasqueradeUser('first-user');
+        });
+
+        act(() => {
+          result.current.setMasqueradeUser('second-user');
+        });
+
+        expect(result.current.masqueradeUser).toBe('second-user');
+      });
+
+      it('should handle multiple sequential updates', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+
+        const users = ['user1@test.com', 'user2@test.com', 'user3@test.com'];
+
+        users.forEach(user => {
+          act(() => {
+            result.current.setMasqueradeUser(user);
+          });
+          expect(result.current.masqueradeUser).toBe(user);
+        });
+      });
+
+      it('should handle unicode characters in usernames', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+
+        const unicodeUser = 'José.García@université.fr';
+
+        act(() => {
+          result.current.setMasqueradeUser(unicodeUser);
+        });
+
+        expect(result.current.masqueradeUser).toBe(unicodeUser);
+      });
+
+      it('should handle very long usernames', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+
+        const longUser = `${'a'.repeat(100)}@example.com`;
+
+        act(() => {
+          result.current.setMasqueradeUser(longUser);
+        });
+
+        expect(result.current.masqueradeUser).toBe(longUser);
+      });
+    });
+
+    describe('masquerade workflow scenarios', () => {
+      it('should handle start masquerade workflow', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+
+        expect(result.current.masqueradeUser).toBeUndefined();
+
+        act(() => {
+          result.current.setMasqueradeUser('target-student@university.edu');
+        });
+
+        expect(result.current.masqueradeUser).toBe('target-student@university.edu');
+      });
+
+      it('should handle stop masquerade workflow', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.setMasqueradeUser('masqueraded-user');
+        });
+
+        act(() => {
+          result.current.setMasqueradeUser(undefined);
+        });
+
+        expect(result.current.masqueradeUser).toBeUndefined();
+      });
+
+      it('should handle switch masquerade user workflow', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.setMasqueradeUser('first-student');
+        });
+        expect(result.current.masqueradeUser).toBe('first-student');
+
+        act(() => {
+          result.current.setMasqueradeUser('second-student');
+        });
+        expect(result.current.masqueradeUser).toBe('second-student');
+
+        act(() => {
+          result.current.setMasqueradeUser(undefined);
+        });
+        expect(result.current.masqueradeUser).toBeUndefined();
+      });
+
+      it('should handle admin masquerade session', () => {
+        const { result } = renderHook(() => useMasquerade(), {
+          wrapper: createWrapper(),
+        });
+        const user = 'user123@institution.edu';
+
+        act(() => {
+          result.current.setMasqueradeUser(user);
+        });
+        expect(result.current.masqueradeUser).toBe(user);
+
+        act(() => {
+          result.current.setMasqueradeUser(undefined);
+        });
+        expect(result.current.masqueradeUser).toBeUndefined();
+      });
+    });
+  });
+
+  describe('reducer functionality', () => {
+    it('should handle SET_MASQUERADE_USER action with string payload', () => {
+      const { result } = renderHook(() => useMasquerade(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.setMasqueradeUser('test-user');
+      });
+
+      expect(result.current.masqueradeUser).toBe('test-user');
+    });
+
+    it('should handle SET_MASQUERADE_USER action with undefined payload', () => {
+      const { result } = renderHook(() => useMasquerade(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.setMasqueradeUser('user');
+      });
+
+      act(() => {
+        result.current.setMasqueradeUser(undefined);
+      });
+
+      expect(result.current.masqueradeUser).toBeUndefined();
+    });
+
+    it('should maintain state immutability', () => {
+      const { result } = renderHook(() => useMasquerade(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.setMasqueradeUser('immutable-test');
+      });
+
+      const currentUser = result.current.masqueradeUser;
+
+      act(() => {
+        result.current.setMasqueradeUser('new-user');
+      });
+
+      expect(currentUser).toBe('immutable-test');
+      expect(result.current.masqueradeUser).toBe('new-user');
+    });
+
+    it('should handle rapid successive updates', () => {
+      const { result } = renderHook(() => useMasquerade(), {
+        wrapper: createWrapper(),
+      });
+
+      const updates = ['user1', 'user2', 'user3', undefined, 'user4'];
+
+      act(() => {
+        updates.forEach(user => {
+          result.current.setMasqueradeUser(user);
+        });
+      });
+
+      expect(result.current.masqueradeUser).toBe('user4');
+    });
+  });
+
+  describe('provider functionality', () => {
+    it('should provide context value correctly', () => {
+      const { result } = renderHook(() => useMasquerade(), {
+        wrapper: createWrapper(),
+      });
+
+      expect(result.current).toBeDefined();
+      expect(result.current.masqueradeUser).toBeUndefined();
+      expect(typeof result.current.setMasqueradeUser).toBe('function');
+    });
+
+    it('should handle provider re-renders without losing state', () => {
+      const TestWrapper = ({ rerenderTrigger, children }: { rerenderTrigger: number; children: React.ReactNode }) => (
+        <MasqueradeProvider>
+          <div data-testid={`rerender-${rerenderTrigger}`}>
+            {children}
+          </div>
+        </MasqueradeProvider>
+      );
+
+      const { result, rerender } = renderHook(() => useMasquerade(), {
+        wrapper: ({ children }) => <TestWrapper rerenderTrigger={1}>{children}</TestWrapper>,
+      });
+
+      act(() => {
+        result.current.setMasqueradeUser('persistent-user');
+      });
+
+      rerender({ rerenderTrigger: 2 });
+
+      expect(result.current.masqueradeUser).toBe('persistent-user');
+    });
+
+    it('should maintain function referential stability', () => {
+      const { result, rerender } = renderHook(() => useMasquerade(), {
+        wrapper: createWrapper(),
+      });
+
+      const initialSetFunction = result.current.setMasqueradeUser;
+
+      rerender();
+
+      expect(result.current.setMasqueradeUser).toBe(initialSetFunction);
+    });
+
+    it('should handle multiple providers independently', () => {
+      const wrapper1 = createWrapper();
+      const wrapper2 = createWrapper();
+
+      const { result: result1 } = renderHook(() => useMasquerade(), { wrapper: wrapper1 });
+      const { result: result2 } = renderHook(() => useMasquerade(), { wrapper: wrapper2 });
+
+      act(() => {
+        result1.current.setMasqueradeUser('user1');
+      });
+
+      act(() => {
+        result2.current.setMasqueradeUser('user2');
+      });
+
+      expect(result1.current.masqueradeUser).toBe('user1');
+      expect(result2.current.masqueradeUser).toBe('user2');
+    });
+  });
+
+  describe('memoization behavior', () => {
+    it('should memoize context value when state does not change', () => {
+      const { result, rerender } = renderHook(() => useMasquerade(), {
+        wrapper: createWrapper(),
+      });
+
+      const firstSetFunction = result.current.setMasqueradeUser;
+
+      rerender();
+
+      expect(result.current.setMasqueradeUser).toBe(firstSetFunction);
+    });
+
+    it('should update memoized value when state changes', () => {
+      const { result } = renderHook(() => useMasquerade(), {
+        wrapper: createWrapper(),
+      });
+
+      const initialUser = result.current.masqueradeUser;
+
+      act(() => {
+        result.current.setMasqueradeUser('changed-user');
+      });
+
+      expect(result.current.masqueradeUser).not.toBe(initialUser);
+      expect(result.current.masqueradeUser).toBe('changed-user');
+    });
+  });
+
+  describe('integration scenarios', () => {
+    it('should handle realistic masquerade admin workflow', () => {
+      const { result } = renderHook(() => useMasquerade(), {
+        wrapper: createWrapper(),
+      });
+
+      expect(result.current.masqueradeUser).toBeUndefined();
+
+      act(() => {
+        result.current.setMasqueradeUser('john.doe@university.edu');
+      });
+      expect(result.current.masqueradeUser).toBe('john.doe@university.edu');
+
+      act(() => {
+        result.current.setMasqueradeUser('jane.smith@university.edu');
+      });
+      expect(result.current.masqueradeUser).toBe('jane.smith@university.edu');
+
+      act(() => {
+        result.current.setMasqueradeUser(undefined);
+      });
+      expect(result.current.masqueradeUser).toBeUndefined();
+    });
+
+    it('should handle development testing workflow', () => {
+      const { result } = renderHook(() => useMasquerade(), {
+        wrapper: createWrapper(),
+      });
+
+      const testUsers = [
+        'test-student-1@test.edu',
+        'test-instructor@test.edu',
+        'test-admin@test.edu',
+      ];
+
+      testUsers.forEach(testUser => {
+        act(() => {
+          result.current.setMasqueradeUser(testUser);
+        });
+        expect(result.current.masqueradeUser).toBe(testUser);
+
+        act(() => {
+          result.current.setMasqueradeUser(undefined);
+        });
+        expect(result.current.masqueradeUser).toBeUndefined();
+      });
+    });
+
+    it('should handle concurrent masquerade sessions in different contexts', () => {
+      const wrapper1 = createWrapper();
+      const wrapper2 = createWrapper();
+
+      const { result: admin1 } = renderHook(() => useMasquerade(), { wrapper: wrapper1 });
+      const { result: admin2 } = renderHook(() => useMasquerade(), { wrapper: wrapper2 });
+
+      act(() => {
+        admin1.current.setMasqueradeUser('student1@university.edu');
+        admin2.current.setMasqueradeUser('student2@university.edu');
+      });
+
+      expect(admin1.current.masqueradeUser).toBe('student1@university.edu');
+      expect(admin2.current.masqueradeUser).toBe('student2@university.edu');
+
+      act(() => {
+        admin1.current.setMasqueradeUser(undefined);
+      });
+
+      expect(admin1.current.masqueradeUser).toBeUndefined();
+      expect(admin2.current.masqueradeUser).toBe('student2@university.edu');
+    });
+  });
+
+  describe('type safety and edge cases', () => {
+    it('should handle type-safe user parameter', () => {
+      const { result } = renderHook(() => useMasquerade(), {
+        wrapper: createWrapper(),
+      });
+
+      const stringUser: string = 'typed-user@test.com';
+      const undefinedUser: undefined = undefined;
+
+      act(() => {
+        result.current.setMasqueradeUser(stringUser);
+      });
+      expect(result.current.masqueradeUser).toBe(stringUser);
+
+      act(() => {
+        result.current.setMasqueradeUser(undefinedUser);
+      });
+      expect(result.current.masqueradeUser).toBe(undefinedUser);
+    });
+
+    it('should handle whitespace-only usernames', () => {
+      const { result } = renderHook(() => useMasquerade(), {
+        wrapper: createWrapper(),
+      });
+
+      const whitespaceUser = '   ';
+
+      act(() => {
+        result.current.setMasqueradeUser(whitespaceUser);
+      });
+
+      expect(result.current.masqueradeUser).toBe(whitespaceUser);
+    });
+
+    it('should handle tab and newline characters', () => {
+      const { result } = renderHook(() => useMasquerade(), {
+        wrapper: createWrapper(),
+      });
+
+      const specialCharsUser = 'user\t\nwith\rspecial@chars.com';
+
+      act(() => {
+        result.current.setMasqueradeUser(specialCharsUser);
+      });
+
+      expect(result.current.masqueradeUser).toBe(specialCharsUser);
+    });
+
+    it('should maintain state consistency across multiple updates', () => {
+      const { result } = renderHook(() => useMasquerade(), {
+        wrapper: createWrapper(),
+      });
+
+      const updates = [
+        'user1',
+        undefined,
+        'user2',
+        '',
+        'user3',
+        undefined,
+        'final-user',
+      ];
+
+      updates.forEach(update => {
+        act(() => {
+          result.current.setMasqueradeUser(update);
+        });
+        expect(result.current.masqueradeUser).toBe(update);
+      });
+    });
+  });
+});
diff --git a/src/data/context/MasqueradeProvider.tsx b/src/data/context/MasqueradeProvider.tsx
new file mode 100644
index 000000000..599b43f65
--- /dev/null
+++ b/src/data/context/MasqueradeProvider.tsx
@@ -0,0 +1,62 @@
+import React, {
+  createContext, useContext, useMemo, useReducer, ReactNode,
+} from 'react';
+
+interface MasqueradeContextType {
+  masqueradeUser: string | undefined;
+  setMasqueradeUser: (user: string | undefined) => void;
+}
+
+const MasqueradeContext = createContext<MasqueradeContextType | null>(null);
+
+interface MasqueradeState {
+  masqueradeUser: string | undefined;
+}
+
+const initialState: MasqueradeState = {
+  masqueradeUser: undefined,
+};
+
+type MasqueradeAction = { type: 'SET_MASQUERADE_USER'; payload: string | undefined };
+
+const masqueradeReducer = (state: MasqueradeState, action: MasqueradeAction): MasqueradeState => {
+  switch (action.type) {
+    case 'SET_MASQUERADE_USER':
+      return {
+        ...state,
+        masqueradeUser: action.payload,
+      };
+    /* istanbul ignore next */
+    default:
+      return state;
+  }
+};
+
+interface MasqueradeProviderProps {
+  children: ReactNode;
+}
+
+export const MasqueradeProvider: React.FC<MasqueradeProviderProps> = ({ children }) => {
+  const [state, dispatch] = useReducer(masqueradeReducer, initialState);
+
+  const contextValue = useMemo(() => ({
+    masqueradeUser: state.masqueradeUser,
+    setMasqueradeUser: (user: string | undefined) => {
+      dispatch({ type: 'SET_MASQUERADE_USER', payload: user });
+    },
+  }), [state]);
+
+  return (
+    <MasqueradeContext.Provider value={contextValue}>
+      {children}
+    </MasqueradeContext.Provider>
+  );
+};
+
+export const useMasquerade = (): MasqueradeContextType => {
+  const context = useContext(MasqueradeContext);
+  if (!context) {
+    throw new Error('useMasquerade must be used within a MasqueradeProvider');
+  }
+  return context;
+};
diff --git a/src/data/context/SelectSession.test.tsx b/src/data/context/SelectSession.test.tsx
new file mode 100644
index 000000000..bce4ae173
--- /dev/null
+++ b/src/data/context/SelectSession.test.tsx
@@ -0,0 +1,664 @@
+import React from 'react';
+import { renderHook, act } from '@testing-library/react';
+import { SelectSessionModalProvider, useSelectSessionModal } from './SelectSessionProvider';
+
+describe('SelectSessionModalProvider and useSelectSessionModal', () => {
+  // eslint-disable-next-line func-names
+  const createWrapper = () => function ({ children }: { children: React.ReactNode }) {
+    return <SelectSessionModalProvider>{children}</SelectSessionModalProvider>;
+  };
+
+  describe('useSelectSessionModal hook', () => {
+    describe('initial state', () => {
+      it('should return initial select session modal state', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        expect(result.current.selectSessionModal.cardId).toBeNull();
+        expect(typeof result.current.updateSelectSessionModal).toBe('function');
+        expect(typeof result.current.closeSelectSessionModal).toBe('function');
+      });
+
+      it('should have all expected properties in context', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        const expectedProperties = [
+          'selectSessionModal',
+          'updateSelectSessionModal',
+          'closeSelectSessionModal',
+        ];
+
+        expectedProperties.forEach(prop => {
+          expect(result.current).toHaveProperty(prop);
+        });
+      });
+
+      it('should have selectSessionModal with cardId property', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        expect(result.current.selectSessionModal).toHaveProperty('cardId');
+        expect(result.current.selectSessionModal.cardId).toBeNull();
+      });
+    });
+
+    describe('error handling', () => {
+      it('should throw error when used outside of provider', () => {
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+        expect(() => {
+          renderHook(() => useSelectSessionModal());
+        }).toThrow('useSelectSessionModal must be used within a SelectSessionModalProvider');
+
+        consoleErrorSpy.mockRestore();
+      });
+
+      it('should throw error with correct message when context is null', () => {
+        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+        try {
+          renderHook(() => useSelectSessionModal());
+        } catch (error) {
+          expect(error).toBeInstanceOf(Error);
+          expect((error as Error).message).toBe('useSelectSessionModal must be used within a SelectSessionModalProvider');
+        }
+
+        consoleErrorSpy.mockRestore();
+      });
+    });
+  });
+
+  describe('modal state management', () => {
+    describe('updateSelectSessionModal', () => {
+      it('should set cardId to string value', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        const testCardId = 'card-123';
+
+        act(() => {
+          result.current.updateSelectSessionModal(testCardId);
+        });
+
+        expect(result.current.selectSessionModal.cardId).toBe(testCardId);
+      });
+
+      it('should set cardId to null', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.updateSelectSessionModal('card-123');
+        });
+
+        act(() => {
+          result.current.updateSelectSessionModal(null);
+        });
+
+        expect(result.current.selectSessionModal.cardId).toBeNull();
+      });
+
+      it('should handle various cardId formats', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        const cardIds = [
+          'card-1',
+          'card-abc-123',
+          'course-card-uuid-456',
+          'simple-id',
+          'id_with_underscores',
+          'id-with-dashes',
+          '12345',
+          'a',
+        ];
+
+        cardIds.forEach(cardId => {
+          act(() => {
+            result.current.updateSelectSessionModal(cardId);
+          });
+          expect(result.current.selectSessionModal.cardId).toBe(cardId);
+        });
+      });
+
+      it('should handle empty string cardId', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.updateSelectSessionModal('');
+        });
+
+        expect(result.current.selectSessionModal.cardId).toBe('');
+      });
+
+      it('should handle long cardId strings', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        const longCardId = `card-${'a'.repeat(100)}`;
+
+        act(() => {
+          result.current.updateSelectSessionModal(longCardId);
+        });
+
+        expect(result.current.selectSessionModal.cardId).toBe(longCardId);
+      });
+
+      it('should handle special characters in cardId', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        const specialCardId = 'card@123#$%^&*()';
+
+        act(() => {
+          result.current.updateSelectSessionModal(specialCardId);
+        });
+
+        expect(result.current.selectSessionModal.cardId).toBe(specialCardId);
+      });
+
+      it('should handle unicode characters in cardId', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        const unicodeCardId = 'card-节点-123';
+
+        act(() => {
+          result.current.updateSelectSessionModal(unicodeCardId);
+        });
+
+        expect(result.current.selectSessionModal.cardId).toBe(unicodeCardId);
+      });
+
+      it('should replace existing cardId', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.updateSelectSessionModal('first-card');
+        });
+
+        act(() => {
+          result.current.updateSelectSessionModal('second-card');
+        });
+
+        expect(result.current.selectSessionModal.cardId).toBe('second-card');
+      });
+
+      it('should handle multiple sequential updates', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        const cardIds = ['card-1', 'card-2', 'card-3', null, 'card-4'];
+
+        cardIds.forEach(cardId => {
+          act(() => {
+            result.current.updateSelectSessionModal(cardId);
+          });
+          expect(result.current.selectSessionModal.cardId).toBe(cardId);
+        });
+      });
+    });
+
+    describe('closeSelectSessionModal', () => {
+      it('should set cardId to null when modal is closed', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.updateSelectSessionModal('card-123');
+        });
+
+        act(() => {
+          result.current.closeSelectSessionModal();
+        });
+
+        expect(result.current.selectSessionModal.cardId).toBeNull();
+      });
+
+      it('should close modal when cardId is already null', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.closeSelectSessionModal();
+        });
+
+        expect(result.current.selectSessionModal.cardId).toBeNull();
+      });
+
+      it('should close modal multiple times without error', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        act(() => {
+          result.current.closeSelectSessionModal();
+          result.current.closeSelectSessionModal();
+          result.current.closeSelectSessionModal();
+        });
+
+        expect(result.current.selectSessionModal.cardId).toBeNull();
+      });
+
+      it('should work correctly after multiple open and close cycles', () => {
+        const { result } = renderHook(() => useSelectSessionModal(), {
+          wrapper: createWrapper(),
+        });
+
+        const cycles = [
+          'card-1',
+          'card-2',
+          'card-3',
+        ];
+
+        cycles.forEach(cardId => {
+          act(() => {
+            result.current.updateSelectSessionModal(cardId);
+          });
+          expect(result.current.selectSessionModal.cardId).toBe(cardId);
+
+          act(() => {
+            result.current.closeSelectSessionModal();
+          });
+          expect(result.current.selectSessionModal.cardId).toBeNull();
+        });
+      });
+    });
+  });
+
+  describe('reducer functionality', () => {
+    it('should handle UPDATE_SELECT_SESSION_MODAL action correctly', () => {
+      const { result } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.updateSelectSessionModal('test-card');
+      });
+
+      expect(result.current.selectSessionModal.cardId).toBe('test-card');
+    });
+
+    it('should handle CLOSE_SELECT_SESSION_MODAL action correctly', () => {
+      const { result } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.updateSelectSessionModal('test-card');
+      });
+
+      act(() => {
+        result.current.closeSelectSessionModal();
+      });
+
+      expect(result.current.selectSessionModal.cardId).toBeNull();
+    });
+
+    it('should maintain state immutability', () => {
+      const { result } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      act(() => {
+        result.current.updateSelectSessionModal('immutable-test');
+      });
+
+      const currentState = result.current.selectSessionModal;
+
+      act(() => {
+        result.current.updateSelectSessionModal('new-card');
+      });
+
+      expect(currentState.cardId).toBe('immutable-test');
+      expect(result.current.selectSessionModal.cardId).toBe('new-card');
+      expect(result.current.selectSessionModal).not.toBe(currentState);
+    });
+
+    it('should handle rapid successive updates', () => {
+      const { result } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      const updates = ['card1', 'card2', 'card3', null, 'card4'];
+
+      act(() => {
+        updates.forEach(cardId => {
+          result.current.updateSelectSessionModal(cardId);
+        });
+      });
+
+      expect(result.current.selectSessionModal.cardId).toBe('card4');
+    });
+
+    it('should create new state object on each update', () => {
+      const { result } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      const initialState = result.current.selectSessionModal;
+
+      act(() => {
+        result.current.updateSelectSessionModal('new-card');
+      });
+
+      const updatedState = result.current.selectSessionModal;
+
+      expect(updatedState).not.toBe(initialState);
+      expect(updatedState.cardId).not.toBe(initialState.cardId);
+    });
+  });
+
+  describe('provider functionality', () => {
+    it('should provide context value correctly', () => {
+      const { result } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      expect(result.current).toBeDefined();
+      expect(result.current.selectSessionModal).toBeDefined();
+      expect(result.current.selectSessionModal.cardId).toBeNull();
+      expect(typeof result.current.updateSelectSessionModal).toBe('function');
+      expect(typeof result.current.closeSelectSessionModal).toBe('function');
+    });
+
+    it('should handle provider re-renders without losing state', () => {
+      const TestWrapper = ({ rerenderTrigger, children }: { rerenderTrigger: number; children: React.ReactNode }) => (
+        <SelectSessionModalProvider>
+          <div data-testid={`rerender-${rerenderTrigger}`}>
+            {children}
+          </div>
+        </SelectSessionModalProvider>
+      );
+
+      const { result, rerender } = renderHook(() => useSelectSessionModal(), {
+        wrapper: ({ children }) => <TestWrapper rerenderTrigger={1}>{children}</TestWrapper>,
+      });
+
+      act(() => {
+        result.current.updateSelectSessionModal('persistent-card');
+      });
+
+      rerender({ rerenderTrigger: 2 });
+
+      expect(result.current.selectSessionModal.cardId).toBe('persistent-card');
+    });
+
+    it('should maintain function referential stability', () => {
+      const { result, rerender } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      const initialFunctions = {
+        updateSelectSessionModal: result.current.updateSelectSessionModal,
+        closeSelectSessionModal: result.current.closeSelectSessionModal,
+      };
+
+      rerender();
+
+      expect(result.current.updateSelectSessionModal).toBe(initialFunctions.updateSelectSessionModal);
+      expect(result.current.closeSelectSessionModal).toBe(initialFunctions.closeSelectSessionModal);
+    });
+
+    it('should handle multiple providers independently', () => {
+      const wrapper1 = createWrapper();
+      const wrapper2 = createWrapper();
+
+      const { result: result1 } = renderHook(() => useSelectSessionModal(), { wrapper: wrapper1 });
+      const { result: result2 } = renderHook(() => useSelectSessionModal(), { wrapper: wrapper2 });
+
+      act(() => {
+        result1.current.updateSelectSessionModal('card1');
+      });
+
+      act(() => {
+        result2.current.updateSelectSessionModal('card2');
+      });
+
+      expect(result1.current.selectSessionModal.cardId).toBe('card1');
+      expect(result2.current.selectSessionModal.cardId).toBe('card2');
+    });
+  });
+
+  describe('memoization behavior', () => {
+    it('should memoize context value when state does not change', () => {
+      const { result, rerender } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      const initialFunctions = {
+        updateSelectSessionModal: result.current.updateSelectSessionModal,
+        closeSelectSessionModal: result.current.closeSelectSessionModal,
+      };
+
+      rerender();
+
+      expect(result.current.updateSelectSessionModal).toBe(initialFunctions.updateSelectSessionModal);
+      expect(result.current.closeSelectSessionModal).toBe(initialFunctions.closeSelectSessionModal);
+    });
+
+    it('should update memoized value when selectSessionModal state changes', () => {
+      const { result } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      const initialCardId = result.current.selectSessionModal.cardId;
+
+      act(() => {
+        result.current.updateSelectSessionModal('changed-card');
+      });
+
+      expect(result.current.selectSessionModal.cardId).not.toBe(initialCardId);
+      expect(result.current.selectSessionModal.cardId).toBe('changed-card');
+    });
+  });
+
+  describe('integration scenarios', () => {
+    it('should handle realistic modal workflow', () => {
+      const { result } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      expect(result.current.selectSessionModal.cardId).toBeNull();
+
+      act(() => {
+        result.current.updateSelectSessionModal('course-card-123');
+      });
+      expect(result.current.selectSessionModal.cardId).toBe('course-card-123');
+
+      act(() => {
+        result.current.closeSelectSessionModal();
+      });
+      expect(result.current.selectSessionModal.cardId).toBeNull();
+    });
+
+    it('should handle session selection workflow for different courses', () => {
+      const { result } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      const courseCards = [
+        'course-cs101-card',
+        'course-math201-card',
+        'course-physics301-card',
+      ];
+
+      courseCards.forEach(cardId => {
+        act(() => {
+          result.current.updateSelectSessionModal(cardId);
+        });
+        expect(result.current.selectSessionModal.cardId).toBe(cardId);
+
+        act(() => {
+          result.current.closeSelectSessionModal();
+        });
+        expect(result.current.selectSessionModal.cardId).toBeNull();
+      });
+    });
+
+    it('should handle switching between different cards without closing', () => {
+      const { result } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      const cardSequence = [
+        'card-A',
+        'card-B',
+        'card-C',
+        'card-D',
+      ];
+
+      cardSequence.forEach(cardId => {
+        act(() => {
+          result.current.updateSelectSessionModal(cardId);
+        });
+        expect(result.current.selectSessionModal.cardId).toBe(cardId);
+      });
+
+      act(() => {
+        result.current.closeSelectSessionModal();
+      });
+      expect(result.current.selectSessionModal.cardId).toBeNull();
+    });
+
+    it('should handle entitlement selection modal workflow', () => {
+      const { result } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      const entitlementCard = 'entitlement-card-uuid-456';
+
+      act(() => {
+        result.current.updateSelectSessionModal(entitlementCard);
+      });
+      expect(result.current.selectSessionModal.cardId).toBe(entitlementCard);
+
+      act(() => {
+        result.current.updateSelectSessionModal(null);
+      });
+      expect(result.current.selectSessionModal.cardId).toBeNull();
+
+      act(() => {
+        result.current.updateSelectSessionModal(entitlementCard);
+      });
+      expect(result.current.selectSessionModal.cardId).toBe(entitlementCard);
+
+      act(() => {
+        result.current.closeSelectSessionModal();
+      });
+      expect(result.current.selectSessionModal.cardId).toBeNull();
+    });
+
+    it('should handle concurrent modal operations in different contexts', () => {
+      const wrapper1 = createWrapper();
+      const wrapper2 = createWrapper();
+
+      const { result: result1 } = renderHook(() => useSelectSessionModal(), { wrapper: wrapper1 });
+      const { result: result2 } = renderHook(() => useSelectSessionModal(), { wrapper: wrapper2 });
+
+      act(() => {
+        result1.current.updateSelectSessionModal('modal-1-card');
+        result2.current.updateSelectSessionModal('modal-2-card');
+      });
+
+      expect(result1.current.selectSessionModal.cardId).toBe('modal-1-card');
+      expect(result2.current.selectSessionModal.cardId).toBe('modal-2-card');
+
+      act(() => {
+        result1.current.closeSelectSessionModal();
+      });
+
+      expect(result1.current.selectSessionModal.cardId).toBeNull();
+      expect(result2.current.selectSessionModal.cardId).toBe('modal-2-card');
+    });
+  });
+
+  describe('type safety and edge cases', () => {
+    it('should handle type-safe cardId parameter', () => {
+      const { result } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      const stringCardId: string = 'typed-card-123';
+      const nullCardId: null = null;
+
+      act(() => {
+        result.current.updateSelectSessionModal(stringCardId);
+      });
+      expect(result.current.selectSessionModal.cardId).toBe(stringCardId);
+
+      act(() => {
+        result.current.updateSelectSessionModal(nullCardId);
+      });
+      expect(result.current.selectSessionModal.cardId).toBe(nullCardId);
+    });
+
+    it('should maintain state consistency across multiple updates', () => {
+      const { result } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      const updates = [
+        'card-1',
+        null,
+        'card-2',
+        '',
+        'card-3',
+        null,
+        'final-card',
+      ];
+
+      updates.forEach(update => {
+        act(() => {
+          result.current.updateSelectSessionModal(update);
+        });
+        expect(result.current.selectSessionModal.cardId).toBe(update);
+      });
+    });
+
+    it('should handle whitespace-only cardIds', () => {
+      const { result } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      const whitespaceCardId = '   ';
+
+      act(() => {
+        result.current.updateSelectSessionModal(whitespaceCardId);
+      });
+
+      expect(result.current.selectSessionModal.cardId).toBe(whitespaceCardId);
+    });
+
+    it('should handle newlines and tabs in cardIds', () => {
+      const { result } = renderHook(() => useSelectSessionModal(), {
+        wrapper: createWrapper(),
+      });
+
+      const specialCharsCardId = 'card\t\nwith\rspecial-chars';
+
+      act(() => {
+        result.current.updateSelectSessionModal(specialCharsCardId);
+      });
+
+      expect(result.current.selectSessionModal.cardId).toBe(specialCharsCardId);
+    });
+  });
+});
diff --git a/src/data/context/SelectSessionProvider.tsx b/src/data/context/SelectSessionProvider.tsx
new file mode 100644
index 000000000..c6357528c
--- /dev/null
+++ b/src/data/context/SelectSessionProvider.tsx
@@ -0,0 +1,81 @@
+import React, {
+  createContext, useContext, useReducer, useMemo, ReactNode,
+} from 'react';
+
+interface SelectSessionModalState {
+  cardId: string | null;
+}
+
+interface SelectSessionModalContextType {
+  selectSessionModal: SelectSessionModalState;
+  updateSelectSessionModal: (cardId: string | null) => void;
+  closeSelectSessionModal: () => void;
+}
+
+const SelectSessionModalContext = createContext<SelectSessionModalContextType | null>(null);
+
+interface State {
+  selectSessionModal: SelectSessionModalState;
+}
+
+type Action =
+  | { type: 'UPDATE_SELECT_SESSION_MODAL'; payload: string | null }
+  | { type: 'CLOSE_SELECT_SESSION_MODAL' };
+
+const initialState: State = {
+  selectSessionModal: { cardId: null },
+};
+
+const selectSessionModalReducer = (state: State, action: Action): State => {
+  switch (action.type) {
+    case 'UPDATE_SELECT_SESSION_MODAL':
+      return {
+        ...state,
+        selectSessionModal: { cardId: action.payload },
+      };
+    case 'CLOSE_SELECT_SESSION_MODAL':
+      return {
+        ...state,
+        selectSessionModal: { cardId: null },
+      };
+    /* istanbul ignore next */
+    default:
+      return state;
+  }
+};
+
+interface SelectSessionModalProviderProps {
+  children: ReactNode;
+}
+
+export const SelectSessionModalProvider: React.FC<SelectSessionModalProviderProps> = ({ children }) => {
+  const [state, dispatch] = useReducer(selectSessionModalReducer, initialState);
+
+  const updateSelectSessionModal = (cardId: string | null) => {
+    dispatch({ type: 'UPDATE_SELECT_SESSION_MODAL', payload: cardId });
+  };
+
+  const closeSelectSessionModal = () => {
+    dispatch({ type: 'CLOSE_SELECT_SESSION_MODAL' });
+  };
+
+  const contextValue = useMemo(() => ({
+    selectSessionModal: state.selectSessionModal,
+    updateSelectSessionModal,
+    closeSelectSessionModal,
+  }), [state.selectSessionModal]);
+
+  return (
+    <SelectSessionModalContext.Provider value={contextValue}>
+      {children}
+    </SelectSessionModalContext.Provider>
+  );
+};
+
+export const useSelectSessionModal = (): SelectSessionModalContextType => {
+  const context = useContext(SelectSessionModalContext);
+  if (!context) {
+    throw new Error('useSelectSessionModal must be used within a SelectSessionModalProvider');
+  }
+  return context;
+};
diff --git a/src/data/context/index.test.tsx b/src/data/context/index.test.tsx
new file mode 100644
index 000000000..772820a76
--- /dev/null
+++ b/src/data/context/index.test.tsx
@@ -0,0 +1,62 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import ContextProviders from './index';
+import { useBackedData } from './BackedDataProvider';
+import { useMasquerade } from './MasqueradeProvider';
+import { useFilters } from './FiltersProvider';
+import { useSelectSessionModal } from './SelectSessionProvider';
+
+const TestComponent = () => {
+  const backedData = useBackedData();
+  const masquerade = useMasquerade();
+  const filters = useFilters();
+  const selectSessionModal = useSelectSessionModal();
+
+  return (
+    <div>
+      <div>{backedData ? 'BackedData Available' : 'BackedData Not Available'}</div>
+      <div>{masquerade ? 'Masquerade Available' : 'Masquerade Not Available'}</div>
+      <div>{filters ? 'Filters Available' : 'Filters Not Available'}</div>
+      <div>{selectSessionModal ? 'SelectSession Available' : 'SelectSession Not Available'}</div>
+    </div>
+  );
+};
+
+describe('ContextProviders', () => {
+  it('should render children', () => {
+    render(
+      <ContextProviders>
+        <div>Test Child</div>
+      </ContextProviders>,
+    );
+
+    expect(screen.getByText('Test Child')).toBeInTheDocument();
+  });
+
+  it('should provide all context providers to children', () => {
+    render(
+      <ContextProviders>
+        <TestComponent />
+      </ContextProviders>,
+    );
+
+    expect(screen.getByText('BackedData Available')).toBeInTheDocument();
+    expect(screen.getByText('Masquerade Available')).toBeInTheDocument();
+    expect(screen.getByText('Filters Available')).toBeInTheDocument();
+    expect(screen.getByText('SelectSession Available')).toBeInTheDocument();
+  });
+
+  it('should render multiple children', () => {
+    render(
+      <ContextProviders>
+        <div>First Child</div>
+        <div>Second Child</div>
+        <div>Third Child</div>
+      </ContextProviders>,
+    );
+
+    expect(screen.getByText('First Child')).toBeInTheDocument();
+    expect(screen.getByText('Second Child')).toBeInTheDocument();
+    expect(screen.getByText('Third Child')).toBeInTheDocument();
+  });
+});
diff --git a/src/data/context/index.tsx b/src/data/context/index.tsx
new file mode 100644
index 000000000..1f0d52d6c
--- /dev/null
+++ b/src/data/context/index.tsx
@@ -0,0 +1,25 @@
+import { BackedDataProvider, useBackedData } from './BackedDataProvider';
+import { MasqueradeProvider, useMasquerade } from './MasqueradeProvider';
+import { FiltersProvider, useFilters } from './FiltersProvider';
+import { SelectSessionModalProvider, useSelectSessionModal } from './SelectSessionProvider';
+
+type ContextProvidersProps = {
+  children: React.ReactNode;
+};
+
+const ContextProviders = ({ children }: ContextProvidersProps) => (
+  <BackedDataProvider>
+    <MasqueradeProvider>
+      <FiltersProvider>
+        <SelectSessionModalProvider>
+          {children}
+        </SelectSessionModalProvider>
+      </FiltersProvider>
+    </MasqueradeProvider>
+  </BackedDataProvider>
+);
+
+export {
+  useBackedData, useMasquerade, useFilters, useSelectSessionModal,
+};
+export default ContextProviders;
diff --git a/src/data/hooks/index.ts b/src/data/hooks/index.ts
new file mode 100644
index 000000000..1283d5121
--- /dev/null
+++ b/src/data/hooks/index.ts
@@ -0,0 +1,21 @@
+import { useInitializeLearnerHome } from './queryHooks';
+import {
+  useUnenrollFromCourse,
+  useUpdateEntitlementEnrollment,
+  useDeleteEntitlementEnrollment,
+  useUpdateEmailSettings,
+  useLogShare,
+  useCreateCreditRequest,
+  useSendConfirmEmail,
+} from './mutationHooks';
+
+export {
+  useInitializeLearnerHome,
+  useUnenrollFromCourse,
+  useUpdateEntitlementEnrollment,
+  useDeleteEntitlementEnrollment,
+  useUpdateEmailSettings,
+  useLogShare,
+  useCreateCreditRequest,
+  useSendConfirmEmail,
+};
diff --git a/src/data/hooks/mutationHooks.test.tsx b/src/data/hooks/mutationHooks.test.tsx
new file mode 100644
index 000000000..fe5a1863b
--- /dev/null
+++ b/src/data/hooks/mutationHooks.test.tsx
@@ -0,0 +1,382 @@
+import { renderHook } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { logError } from '@edx/frontend-platform/logging';
+import {
+  useUnenrollFromCourse,
+  useUpdateEntitlementEnrollment,
+  useDeleteEntitlementEnrollment,
+  useUpdateEmailSettings,
+  useLogShare,
+  useCreateCreditRequest,
+  useSendConfirmEmail,
+} from './mutationHooks';
+import * as api from '../services/lms/api';
+
+// Mock external dependencies
+jest.mock('@edx/frontend-platform/logging');
+jest.mock('data/context/MasqueradeProvider');
+jest.mock('data/context/BackedDataProvider');
+jest.mock('data/services/lms/api');
+
+const mockLogError = logError as jest.MockedFunction<typeof logError>;
+
+// Create a test wrapper with QueryClient
+const createWrapper = () => {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+        gcTime: 0,
+      },
+      mutations: {
+        retry: false,
+      },
+    },
+  });
+
+  // eslint-disable-next-line func-names
+  return function ({ children }: { children: React.ReactNode }) {
+    return (
+      <QueryClientProvider client={queryClient}>
+        {children}
+      </QueryClientProvider>
+    );
+  };
+};
+
+describe('mutationHooks', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('useUnenrollFromCourse', () => {
+    it('should unenroll successfully and invalidate queries', async () => {
+      const queryClient = new QueryClient();
+      const invalidateQueriesSpy = jest.spyOn(queryClient, 'invalidateQueries');
+      (api.unenrollFromCourse as jest.Mock).mockResolvedValue({});
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <QueryClientProvider client={queryClient}>
+          {children}
+        </QueryClientProvider>
+      );
+
+      const { result } = renderHook(() => useUnenrollFromCourse(), { wrapper });
+
+      await result.current.mutateAsync({ courseId: 'test-course-id' });
+
+      expect(api.unenrollFromCourse).toHaveBeenCalledWith({ courseId: 'test-course-id' });
+      expect(invalidateQueriesSpy).toHaveBeenCalledWith({
+        queryKey: expect.arrayContaining(['learner-dashboard', 'initialize']),
+      });
+    });
+
+    it('should log error when unenroll fails', async () => {
+      const error = new Error('Network error');
+      (api.unenrollFromCourse as jest.Mock).mockRejectedValue(error);
+
+      const { result } = renderHook(() => useUnenrollFromCourse(), {
+        wrapper: createWrapper(),
+      });
+
+      await expect(result.current.mutateAsync({ courseId: 'test-course-id' }))
+        .rejects.toThrow('Network error');
+
+      expect(mockLogError).toHaveBeenCalledWith(
+        'Failed to unenroll from course test-course-id:',
+        error,
+      );
+    });
+  });
+
+  describe('useUpdateEntitlementEnrollment', () => {
+    it('should update entitlement enrollment successfully', async () => {
+      const queryClient = new QueryClient();
+      const invalidateQueriesSpy = jest.spyOn(queryClient, 'invalidateQueries');
+      (api.updateEntitlementEnrollment as jest.Mock).mockResolvedValue({});
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <QueryClientProvider client={queryClient}>
+          {children}
+        </QueryClientProvider>
+      );
+
+      const { result } = renderHook(() => useUpdateEntitlementEnrollment(), { wrapper });
+
+      await result.current.mutateAsync({ uuid: 'test-uuid', courseId: 'test-course' });
+
+      expect(api.updateEntitlementEnrollment).toHaveBeenCalledWith({
+        uuid: 'test-uuid',
+        courseId: 'test-course',
+      });
+      expect(invalidateQueriesSpy).toHaveBeenCalled();
+    });
+
+    it('should log error when update fails', async () => {
+      const error = new Error('Update failed');
+      (api.updateEntitlementEnrollment as jest.Mock).mockRejectedValue(error);
+
+      const { result } = renderHook(() => useUpdateEntitlementEnrollment(), {
+        wrapper: createWrapper(),
+      });
+
+      await expect(result.current.mutateAsync({ uuid: 'test-uuid', courseId: 'test-course' }))
+        .rejects.toThrow('Update failed');
+
+      expect(mockLogError).toHaveBeenCalledWith(
+        'Failed to update entitlement enrollment for UUID test-uuid:',
+        error,
+      );
+    });
+  });
+
+  describe('useDeleteEntitlementEnrollment', () => {
+    it('should delete entitlement enrollment successfully', async () => {
+      const queryClient = new QueryClient();
+      const invalidateQueriesSpy = jest.spyOn(queryClient, 'invalidateQueries');
+      (api.deleteEntitlementEnrollment as jest.Mock).mockResolvedValue({});
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <QueryClientProvider client={queryClient}>
+          {children}
+        </QueryClientProvider>
+      );
+
+      const { result } = renderHook(() => useDeleteEntitlementEnrollment(), { wrapper });
+
+      await result.current.mutateAsync({ uuid: 'test-uuid', isRefundable: true });
+
+      expect(api.deleteEntitlementEnrollment).toHaveBeenCalledWith({
+        uuid: 'test-uuid',
+        isRefundable: true,
+      });
+      expect(invalidateQueriesSpy).toHaveBeenCalled();
+    });
+
+    it('should log error when deletion fails', async () => {
+      const error = new Error('Deletion failed');
+      (api.deleteEntitlementEnrollment as jest.Mock).mockRejectedValue(error);
+
+      const { result } = renderHook(() => useDeleteEntitlementEnrollment(), {
+        wrapper: createWrapper(),
+      });
+
+      await expect(result.current.mutateAsync({ uuid: 'test-uuid', isRefundable: false }))
+        .rejects.toThrow('Deletion failed');
+
+      expect(mockLogError).toHaveBeenCalledWith(
+        'Failed to delete entitlement enrollment for UUID test-uuid:',
+        error,
+      );
+    });
+  });
+
+  describe('useUpdateEmailSettings', () => {
+    it('should update email settings successfully', async () => {
+      const queryClient = new QueryClient();
+      const invalidateQueriesSpy = jest.spyOn(queryClient, 'invalidateQueries');
+      (api.updateEmailSettings as jest.Mock).mockResolvedValue({});
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <QueryClientProvider client={queryClient}>
+          {children}
+        </QueryClientProvider>
+      );
+
+      const { result } = renderHook(() => useUpdateEmailSettings(), { wrapper });
+
+      await result.current.mutateAsync({ courseId: 'test-course', enable: true });
+
+      expect(api.updateEmailSettings).toHaveBeenCalledWith({
+        courseId: 'test-course',
+        enable: true,
+      });
+      expect(invalidateQueriesSpy).toHaveBeenCalled();
+    });
+
+    it('should log error when email settings update fails', async () => {
+      const error = new Error('Email settings update failed');
+      (api.updateEmailSettings as jest.Mock).mockRejectedValue(error);
+
+      const { result } = renderHook(() => useUpdateEmailSettings(), {
+        wrapper: createWrapper(),
+      });
+
+      await expect(result.current.mutateAsync({ courseId: 'test-course', enable: false }))
+        .rejects.toThrow('Email settings update failed');
+
+      expect(mockLogError).toHaveBeenCalledWith(
+        'Failed to update email settings for course test-course:',
+        error,
+      );
+    });
+  });
+
+  describe('useLogShare', () => {
+    it('should log share event successfully', async () => {
+      (api.logShare as jest.Mock).mockResolvedValue({});
+
+      const { result } = renderHook(() => useLogShare(), {
+        wrapper: createWrapper(),
+      });
+
+      await result.current.mutateAsync({ courseId: 'test-course', site: 'facebook' });
+
+      expect(api.logShare).toHaveBeenCalledWith({
+        courseId: 'test-course',
+        site: 'facebook',
+      });
+    });
+
+    it('should log error when share logging fails', async () => {
+      const error = new Error('Share logging failed');
+      (api.logShare as jest.Mock).mockRejectedValue(error);
+
+      const { result } = renderHook(() => useLogShare(), {
+        wrapper: createWrapper(),
+      });
+
+      await expect(result.current.mutateAsync({ courseId: 'test-course', site: 'twitter' }))
+        .rejects.toThrow('Share logging failed');
+
+      expect(mockLogError).toHaveBeenCalledWith(
+        'Failed to log share event for course test-course on twitter:',
+        error,
+      );
+    });
+  });
+
+  describe('useCreateCreditRequest', () => {
+    it('should create credit request successfully', async () => {
+      const queryClient = new QueryClient();
+      const invalidateQueriesSpy = jest.spyOn(queryClient, 'invalidateQueries');
+      (api.createCreditRequest as jest.Mock).mockResolvedValue({});
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <QueryClientProvider client={queryClient}>
+          {children}
+        </QueryClientProvider>
+      );
+
+      const { result } = renderHook(() => useCreateCreditRequest(), { wrapper });
+
+      const creditParams = {
+        providerId: 'test-provider',
+        courseId: 'test-course',
+        username: 'test-user',
+      };
+
+      await result.current.mutateAsync(creditParams);
+
+      expect(api.createCreditRequest).toHaveBeenCalledWith(creditParams);
+      expect(invalidateQueriesSpy).toHaveBeenCalled();
+    });
+
+    it('should log error when credit request creation fails', async () => {
+      const error = new Error('Credit request failed');
+      (api.createCreditRequest as jest.Mock).mockRejectedValue(error);
+
+      const { result } = renderHook(() => useCreateCreditRequest(), {
+        wrapper: createWrapper(),
+      });
+
+      const creditParams = {
+        providerId: 'test-provider',
+        courseId: 'test-course',
+        username: 'test-user',
+      };
+
+      await expect(result.current.mutateAsync(creditParams))
+        .rejects.toThrow('Credit request failed');
+
+      expect(mockLogError).toHaveBeenCalledWith(
+        'Failed to create credit request for course test-course with provider test-provider:',
+        error,
+      );
+    });
+  });
+
+  describe('useSendConfirmEmail', () => {
+    it('should send confirmation email successfully', async () => {
+      const queryClient = new QueryClient();
+      const invalidateQueriesSpy = jest.spyOn(queryClient, 'invalidateQueries');
+      (api.sendConfirmEmail as jest.Mock).mockResolvedValue({});
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <QueryClientProvider client={queryClient}>
+          {children}
+        </QueryClientProvider>
+      );
+
+      const sendEmailUrl = 'https://example.com/send-email';
+      const { result } = renderHook(() => useSendConfirmEmail(sendEmailUrl), { wrapper });
+
+      await result.current.mutateAsync();
+
+      expect(api.sendConfirmEmail).toHaveBeenCalledWith(sendEmailUrl);
+      expect(invalidateQueriesSpy).toHaveBeenCalled();
+    });
+
+    it('should log error when sending confirmation email fails', async () => {
+      const error = new Error('Email sending failed');
+      (api.sendConfirmEmail as jest.Mock).mockRejectedValue(error);
+
+      const sendEmailUrl = 'https://example.com/send-email';
+      const { result } = renderHook(() => useSendConfirmEmail(sendEmailUrl), {
+        wrapper: createWrapper(),
+      });
+
+      await expect(result.current.mutateAsync())
+        .rejects.toThrow('Email sending failed');
+
+      expect(mockLogError).toHaveBeenCalledWith(
+        'Failed to send confirmation email:',
+        error,
+      );
+    });
+  });
+
+  describe('Query invalidation behavior', () => {
+    it('should invalidate correct queries for all mutation hooks', async () => {
+      const queryClient = new QueryClient();
+      const invalidateQueriesSpy = jest.spyOn(queryClient, 'invalidateQueries');
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <QueryClientProvider client={queryClient}>
+          {children}
+        </QueryClientProvider>
+      );
+
+      // Mock successful API responses
+      (api.unenrollFromCourse as jest.Mock).mockResolvedValue({});
+      (api.updateEntitlementEnrollment as jest.Mock).mockResolvedValue({});
+      (api.updateEmailSettings as jest.Mock).mockResolvedValue({});
+      (api.createCreditRequest as jest.Mock).mockResolvedValue({});
+      (api.sendConfirmEmail as jest.Mock).mockResolvedValue({});
+
+      // Test each hook that should invalidate queries
+      const hooks = [
+        { hook: useUnenrollFromCourse, params: { courseId: 'test' } },
+        { hook: useUpdateEntitlementEnrollment, params: { uuid: 'test', courseId: 'test' } },
+        { hook: useUpdateEmailSettings, params: { courseId: 'test', enable: true } },
+        { hook: useCreateCreditRequest, params: { providerId: 'test', courseId: 'test', username: 'test' } },
+        { hook: useSendConfirmEmail, params: undefined, arg: 'https://test.com' },
+      ];
+
+      for (const { hook, params, arg } of hooks) {
+        invalidateQueriesSpy.mockClear();
+        // ts-ignore to handle varying params
+        // @ts-ignore
+        const { result } = renderHook(() => (arg ? hook(arg) : hook()), { wrapper });
+
+        // @ts-ignore
+        // eslint-disable-next-line no-await-in-loop
+        await result.current.mutateAsync(params);
+
+        expect(invalidateQueriesSpy).toHaveBeenCalledWith({
+          queryKey: expect.arrayContaining(['learner-dashboard', 'initialize']),
+        });
+      }
+    });
+  });
+});
diff --git a/src/data/hooks/mutationHooks.ts b/src/data/hooks/mutationHooks.ts
new file mode 100644
index 000000000..c2d30a8c4
--- /dev/null
+++ b/src/data/hooks/mutationHooks.ts
@@ -0,0 +1,143 @@
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { logError } from '@edx/frontend-platform/logging';
+import {
+  createCreditRequest,
+  deleteEntitlementEnrollment,
+  logShare,
+  sendConfirmEmail,
+  unenrollFromCourse,
+  updateEmailSettings,
+  updateEntitlementEnrollment,
+} from 'data/services/lms/api';
+import { lernerDashboardQueryKeys } from './queryKeys';
+
+type LogShareParams = {
+  courseId: string;
+  site: string;
+};
+
+const useUnenrollFromCourse = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationKey: lernerDashboardQueryKeys.unenrollFromCourse(),
+    mutationFn: ({ courseId }: { courseId: string }) => unenrollFromCourse({ courseId }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: lernerDashboardQueryKeys.initialize() });
+    },
+    onError: (error, variables) => {
+      logError(`Failed to unenroll from course ${variables.courseId}:`, error);
+    },
+  });
+};
+
+const useUpdateEntitlementEnrollment = () => {
+  const queryClient = useQueryClient();
+
+  type UpdateEntitlementProps = {
+    uuid: string;
+    courseId: string;
+  };
+
+  return useMutation({
+    mutationKey: lernerDashboardQueryKeys.updateEntitlementEnrollment(),
+    mutationFn: ({ uuid, courseId }: UpdateEntitlementProps) => updateEntitlementEnrollment({ uuid, courseId }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: lernerDashboardQueryKeys.initialize() });
+    },
+    onError: (error, variables) => {
+      logError(`Failed to update entitlement enrollment for UUID ${variables.uuid}:`, error);
+    },
+  });
+};
+
+const useDeleteEntitlementEnrollment = () => {
+  const queryClient = useQueryClient();
+
+  type DeleteEntitlParams = {
+    uuid: string;
+    isRefundable: boolean;
+  };
+
+  return useMutation({
+    mutationKey: lernerDashboardQueryKeys.deleteEntitlementEnrollment(),
+    mutationFn: ({ uuid, isRefundable }: DeleteEntitlParams) => deleteEntitlementEnrollment({ uuid, isRefundable }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: lernerDashboardQueryKeys.initialize() });
+    },
+    onError: (error, variables) => {
+      logError(`Failed to delete entitlement enrollment for UUID ${variables.uuid}:`, error);
+    },
+  });
+};
+
+const useUpdateEmailSettings = () => {
+  const queryClient = useQueryClient();
+  type UpdateEmailSettingsParams = {
+    courseId: string;
+    enable: boolean;
+  };
+
+  return useMutation({
+    mutationKey: lernerDashboardQueryKeys.updateEmailSettings(),
+    mutationFn: ({ courseId, enable }: UpdateEmailSettingsParams) => updateEmailSettings({ courseId, enable }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: lernerDashboardQueryKeys.initialize() });
+    },
+    onError: (error, variables) => {
+      logError(`Failed to update email settings for course ${variables.courseId}:`, error);
+    },
+  });
+};
+
+const useLogShare = () => useMutation({
+  mutationKey: lernerDashboardQueryKeys.logShare(),
+  mutationFn: ({ courseId, site }: LogShareParams) => logShare({ courseId, site }),
+  onError: (error, variables) => {
+    logError(`Failed to log share event for course ${variables.courseId} on ${variables.site}:`, error);
+  },
+});
+
+const useCreateCreditRequest = () => {
+  const queryClient = useQueryClient();
+  type CreditParams = {
+    providerId: string;
+    courseId: string;
+    username: string;
+  };
+  return useMutation({
+    mutationKey: lernerDashboardQueryKeys.createCreditRequest(),
+    mutationFn: (props: CreditParams) => createCreditRequest(props),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: lernerDashboardQueryKeys.initialize() });
+    },
+    onError: (error, variables) => {
+      logError(`Failed to create credit request for course ${variables.courseId} with provider ${variables.providerId}:`, error);
+    },
+  });
+};
+
+const useSendConfirmEmail = (sendEmailUrl: string) => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationKey: lernerDashboardQueryKeys.sendConfirmEmail(sendEmailUrl),
+    mutationFn: () => sendConfirmEmail(sendEmailUrl),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: lernerDashboardQueryKeys.initialize() });
+    },
+    onError: (error) => {
+      logError('Failed to send confirmation email:', error);
+    },
+  });
+};
+
+export {
+  useUnenrollFromCourse,
+  useUpdateEntitlementEnrollment,
+  useDeleteEntitlementEnrollment,
+  useUpdateEmailSettings,
+  useLogShare,
+  useCreateCreditRequest,
+  useSendConfirmEmail,
+};
diff --git a/src/data/hooks/queryHooks.test.tsx b/src/data/hooks/queryHooks.test.tsx
new file mode 100644
index 000000000..ce4217372
--- /dev/null
+++ b/src/data/hooks/queryHooks.test.tsx
@@ -0,0 +1,142 @@
+import { renderHook, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { useMasquerade } from 'data/context';
+import { useBackedData } from 'data/context/BackedDataProvider';
+import {
+  useInitializeLearnerHome,
+} from './index';
+import * as api from '../services/lms/api';
+
+// Mock external dependencies
+jest.mock('@edx/frontend-platform/logging');
+jest.mock('data/context/MasqueradeProvider');
+jest.mock('data/context/BackedDataProvider');
+jest.mock('data/services/lms/api');
+
+const mockUseMasquerade = useMasquerade as jest.MockedFunction<typeof useMasquerade>;
+const mockUseBackedData = useBackedData as jest.MockedFunction<typeof useBackedData>;
+
+// Create a test wrapper with QueryClient
+const createWrapper = () => {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+        gcTime: 0,
+      },
+      mutations: {
+        retry: false,
+      },
+    },
+  });
+
+  // eslint-disable-next-line func-names
+  return function ({ children }: { children: React.ReactNode }) {
+    return (
+      <QueryClientProvider client={queryClient}>
+        {children}
+      </QueryClientProvider>
+    );
+  };
+};
+
+describe('queryHooks', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  describe('useInitializeLearnerHome', () => {
+    const mockBackupData = { courses: ['backup-course'], user: 'backup-user' };
+    const mockQueryData = { courses: ['query-course'], user: 'query-user' };
+    const mockSetBackUpData = jest.fn();
+
+    beforeEach(() => {
+      mockUseBackedData.mockReturnValue({
+        backUpData: mockBackupData,
+        setBackUpData: mockSetBackUpData,
+      });
+    });
+
+    it('should use query data when masquerading and query succeeds', async () => {
+      const masqueradeUser = 'test-user';
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser,
+        setMasqueradeUser(): void {
+          throw new Error('Function not implemented.');
+        },
+      });
+      (api.initializeList as jest.Mock).mockResolvedValue(mockQueryData);
+
+      const { result } = renderHook(() => useInitializeLearnerHome(), {
+        wrapper: createWrapper(),
+      });
+
+      await waitFor(() => {
+        expect(result.current.isSuccess).toBe(true);
+      });
+
+      expect(api.initializeList).toHaveBeenCalledWith(masqueradeUser);
+      expect(result.current.data).toEqual(mockQueryData);
+      expect(mockSetBackUpData).not.toHaveBeenCalled();
+    });
+
+    it('should use backup data when masquerading and query fails', async () => {
+      const masqueradeUser = 'test-user';
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser,
+        setMasqueradeUser(): void {
+          throw new Error('Function not implemented.');
+        },
+      });
+      (api.initializeList as jest.Mock).mockRejectedValue(new Error('API Error'));
+
+      const { result } = renderHook(() => useInitializeLearnerHome(), {
+        wrapper: createWrapper(),
+      });
+
+      await waitFor(() => {
+        expect(result.current.isError).toBe(true);
+      });
+
+      expect(api.initializeList).toHaveBeenCalledWith(masqueradeUser);
+      expect(result.current.data).toEqual(mockBackupData);
+      expect(mockSetBackUpData).not.toHaveBeenCalled();
+    });
+
+    it('should not set backup data when masquerading', async () => {
+      const masqueradeUser = 'test-user';
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser,
+        setMasqueradeUser(): void {
+          throw new Error('Function not implemented.');
+        },
+      });
+      (api.initializeList as jest.Mock).mockResolvedValue(mockQueryData);
+
+      renderHook(() => useInitializeLearnerHome(), {
+        wrapper: createWrapper(),
+      });
+
+      await waitFor(() => {
+        expect(mockSetBackUpData).not.toHaveBeenCalled();
+      });
+    });
+
+    it('should have correct query configuration for masquerading', async () => {
+      const masqueradeUser = 'test-user';
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser,
+        setMasqueradeUser(): void {
+          throw new Error('Function not implemented.');
+        },
+      });
+      (api.initializeList as jest.Mock).mockResolvedValue(mockQueryData);
+
+      const { result } = renderHook(() => useInitializeLearnerHome(), {
+        wrapper: createWrapper(),
+      });
+
+      // For masquerading, retryOnMount and refetchOnMount should be false
+      expect(result.current.isRefetchError).toBe(false);
+    });
+  });
+});
diff --git a/src/data/hooks/queryHooks.ts b/src/data/hooks/queryHooks.ts
new file mode 100644
index 000000000..8c355b821
--- /dev/null
+++ b/src/data/hooks/queryHooks.ts
@@ -0,0 +1,34 @@
+import { useQuery } from '@tanstack/react-query';
+import { useEffect } from 'react';
+import { useBackedData, useMasquerade } from 'data/context';
+import {
+  initializeList,
+} from 'data/services/lms/api';
+import { lernerDashboardQueryKeys } from './queryKeys';
+
+const useInitializeLearnerHome = () => {
+  const { masqueradeUser } = useMasquerade();
+  const { backUpData, setBackUpData } = useBackedData();
+
+  const query = useQuery({
+    queryKey: lernerDashboardQueryKeys.initialize(masqueradeUser),
+    queryFn: async () => initializeList(masqueradeUser),
+    retry: false,
+    retryOnMount: !masqueradeUser,
+    refetchOnMount: !masqueradeUser,
+  });
+
+  useEffect(() => {
+    if (!masqueradeUser && query.data) {
+      setBackUpData(query.data);
+    }
+  }, [masqueradeUser, query.data, setBackUpData]);
+
+  const data = masqueradeUser && !query.isError ? query.data : backUpData;
+
+  return { ...query, data };
+};
+
+export {
+  useInitializeLearnerHome,
+};
diff --git a/src/data/hooks/queryKeys.ts b/src/data/hooks/queryKeys.ts
new file mode 100644
index 000000000..4d4e98198
--- /dev/null
+++ b/src/data/hooks/queryKeys.ts
@@ -0,0 +1,12 @@
+export const lernerDashboardQueryKeys = {
+  all: ['learner-dashboard'] as const,
+  initialize: (masqueradedUser?: string | null) => [...lernerDashboardQueryKeys.all, 'initialize', masqueradedUser] as const,
+  masqueradingState: () => [...lernerDashboardQueryKeys.all, 'masqueradingState'] as const,
+  unenrollFromCourse: () => [...lernerDashboardQueryKeys.all, 'unenrollFromCourse'] as const,
+  updateEntitlementEnrollment: () => [...lernerDashboardQueryKeys.all, 'updateEntitlementEnrollment'] as const,
+  deleteEntitlementEnrollment: () => [...lernerDashboardQueryKeys.all, 'deleteEntitlementEnrollment'] as const,
+  updateEmailSettings: () => [...lernerDashboardQueryKeys.all, 'updateEmailSettings'] as const,
+  logShare: () => [...lernerDashboardQueryKeys.all, 'logShare'] as const,
+  createCreditRequest: () => [...lernerDashboardQueryKeys.all, 'createCreditRequest'] as const,
+  sendConfirmEmail: (sendEmailUrl: string) => [...lernerDashboardQueryKeys.all, 'sendConfirmEmail', sendEmailUrl] as const,
+};
diff --git a/src/data/redux/app/index.js b/src/data/redux/app/index.js
deleted file mode 100644
index 8abd5f91d..000000000
--- a/src/data/redux/app/index.js
+++ /dev/null
@@ -1,2 +0,0 @@
-export { actions, reducer } from './reducer';
-export { default as selectors } from './selectors';
diff --git a/src/data/redux/app/reducer.js b/src/data/redux/app/reducer.js
deleted file mode 100644
index a3f94e64a..000000000
--- a/src/data/redux/app/reducer.js
+++ /dev/null
@@ -1,81 +0,0 @@
-import { createSlice } from '@reduxjs/toolkit';
-
-import { StrictDict } from 'utils';
-
-const initialState = {
-  pageNumber: 1,
-  courseData: {},
-  entitlement: [],
-  emailConfirmation: {},
-  enterpriseDashboard: {},
-  platformSettings: {},
-  suggestedCourses: [],
-  selectSessionModal: {},
-  filters: [],
-};
-
-export const cardId = (val) => `card-${val}`;
-
-export const today = Date.now();
-
-/**
- * Creates a redux slice with actions to load dashboard data and manage visual layout
- */
-const app = createSlice({
-  name: 'app',
-  initialState,
-  reducers: {
-    loadCourses: (state, { payload: { courses } }) => ({
-      ...state,
-      courseData: courses.reduce(
-        (obj, curr, index) => {
-          const out = { ...curr, cardId: cardId(index) };
-          if (out.enrollment.lastEnrolled === null) {
-            out.enrollment.lastEnrolled = today;
-          }
-          return { ...obj, [cardId(index)]: out };
-        },
-        {},
-      ),
-    }),
-    loadGlobalData: (state, { payload }) => ({
-      ...state,
-      emailConfirmation: payload.emailConfirmation,
-      enterpriseDashboard: payload.enterpriseDashboard,
-      platformSettings: payload.platformSettings,
-      suggestedCourses: payload.suggestedCourses,
-      socialShareSettings: payload.socialShareSettings,
-    }),
-    updateSelectSessionModal: (state, { payload }) => ({
-      ...state,
-      selectSessionModal: { cardId: payload },
-    }),
-    setPageNumber: (state, { payload }) => ({ ...state, pageNumber: payload }),
-    setFilters: (state, { payload }) => ({
-      ...state,
-      filters: payload,
-    }),
-    addFilter: (state, { payload }) => ({
-      ...state,
-      filters: [...state.filters, payload],
-    }),
-    removeFilter: (state, { payload }) => ({
-      ...state,
-      filters: state.filters.filter(item => item !== payload),
-    }),
-    clearFilters: (state) => ({
-      ...state,
-      filters: [],
-    }),
-  },
-});
-
-const actions = StrictDict(app.actions);
-
-const { reducer } = app;
-
-export {
-  actions,
-  initialState,
-  reducer,
-};
diff --git a/src/data/redux/app/reducer.test.js b/src/data/redux/app/reducer.test.js
deleted file mode 100644
index 5d542223d..000000000
--- a/src/data/redux/app/reducer.test.js
+++ /dev/null
@@ -1,124 +0,0 @@
-import {
-  cardId,
-  initialState,
-  reducer,
-  actions,
-  today,
-} from './reducer';
-
-describe('app reducer', () => {
-  describe('reducers', () => {
-    beforeEach(() => {
-      jest.useFakeTimers();
-    });
-    it('returns initial state', () => {
-      expect(reducer(undefined, {})).toEqual(initialState);
-    });
-    const initialFilter = 'initial filter';
-    const testState = {
-      ...initialState,
-      enrollments: [],
-      courseData: {
-      },
-      entitlement: [],
-      filters: [initialFilter],
-    };
-    describe('action handlers', () => {
-      describe('loadCourses', () => {
-        const courseIds = [
-          'course-1',
-          'course-2',
-          'course-3',
-        ];
-        const entitlementIds = [
-          'entitlement-course-1',
-          'entitlement-course-2',
-        ];
-        const enrollmentData = [
-          {
-            courseRun: { cardId: courseIds[0] },
-            course: 1,
-            some: 'data',
-            enrollment: { lastEnrolled: 'test-last-enrolled' },
-          },
-          {
-            courseRun: { cardId: courseIds[1] },
-            course: 2,
-            some: 'other data',
-            enrollment: { lastEnrolled: 'test-last-enrolled' },
-          },
-          {
-            courseRun: { cardId: courseIds[2] },
-            course: 3,
-            some: 'still different data',
-            enrollment: { lastEnrolled: 'test-last-enrolled' },
-          },
-        ];
-        const entitlementData = [
-          {
-            courseRun: { cardId: entitlementIds[0] },
-            course: 4,
-            some: 'STILL different data',
-            enrollment: { lastEnrolled: null },
-          },
-          {
-            courseRun: { cardId: entitlementIds[1] },
-            course: 5,
-            some: 'still DIFFERENT data',
-            enrollment: { lastEnrolled: null },
-          },
-        ];
-        let out;
-        beforeEach(() => {
-          out = reducer(testState, actions.loadCourses({
-            courses: [...enrollmentData, ...entitlementData],
-          }));
-        });
-        it('loads object keyed by courseRun ids into courseData field', () => {
-          expect(out.courseData).toEqual({
-            [cardId(0)]: { ...enrollmentData[0], cardId: cardId(0) },
-            [cardId(1)]: { ...enrollmentData[1], cardId: cardId(1) },
-            [cardId(2)]: {
-              ...enrollmentData[2],
-              cardId: cardId(2),
-            },
-            [cardId(3)]: {
-              ...entitlementData[0],
-              cardId: cardId(3),
-              enrollment: { lastEnrolled: today },
-            },
-            [cardId(4)]: {
-              ...entitlementData[1],
-              cardId: cardId(4),
-              enrollment: { lastEnrolled: today },
-            },
-          });
-        });
-      });
-      describe('filters', () => {
-        const newFilter = 'new filter';
-        let out;
-        beforeEach(() => {
-          out = reducer(testState, {});
-        });
-        it('overwrites the filters object when using setFilters', () => {
-          expect(out.filters).toEqual([initialFilter]);
-          out = reducer(testState, actions.setFilters([newFilter]));
-          expect(out.filters).toEqual([newFilter]);
-        });
-        it('adds a filter when using addFilter', () => {
-          out = reducer(testState, actions.addFilter(newFilter));
-          expect(out.filters).toEqual([initialFilter, newFilter]);
-        });
-        it('removes a filter when using removeFilter', () => {
-          out = reducer(testState, actions.removeFilter(initialFilter));
-          expect(out.filters).toEqual([]);
-        });
-        it('clears the filters when using clearFilters', () => {
-          out = reducer(testState, actions.clearFilters());
-          expect(out.filters).toEqual([]);
-        });
-      });
-    });
-  });
-});
diff --git a/src/data/redux/app/selectors/appSelectors.js b/src/data/redux/app/selectors/appSelectors.js
deleted file mode 100644
index 255c7976a..000000000
--- a/src/data/redux/app/selectors/appSelectors.js
+++ /dev/null
@@ -1,23 +0,0 @@
-import { createSelector } from 'reselect';
-
-import { StrictDict } from 'utils';
-
-import simpleSelectors from './simpleSelectors';
-import * as module from './appSelectors';
-
-export const numCourses = createSelector(
-  [simpleSelectors.courseData],
-  (courseData) => Object.keys(courseData).length,
-);
-export const hasCourses = createSelector([module.numCourses], (num) => num > 0);
-
-export const showSelectSessionModal = createSelector(
-  [simpleSelectors.selectSessionModal],
-  (data) => data.cardId != null,
-);
-
-export default StrictDict({
-  numCourses,
-  hasCourses,
-  showSelectSessionModal,
-});
diff --git a/src/data/redux/app/selectors/appSelectors.test.js b/src/data/redux/app/selectors/appSelectors.test.js
deleted file mode 100644
index 09b528c08..000000000
--- a/src/data/redux/app/selectors/appSelectors.test.js
+++ /dev/null
@@ -1,28 +0,0 @@
-import simpleSelectors from './simpleSelectors';
-import * as appSelectors from './appSelectors';
-
-describe('basic app selectors', () => {
-  describe('numCourses', () => {
-    it('returns the number of courses in the courseData object', () => {
-      const { preSelectors, cb } = appSelectors.numCourses;
-      expect(preSelectors).toEqual([simpleSelectors.courseData]);
-      expect(cb({ course1: 'data', course2: 'data', course3: 'data' })).toEqual(3);
-    });
-  });
-  describe('hasCourses', () => {
-    it('returns true iff numCourses is greater than 0', () => {
-      const { preSelectors, cb } = appSelectors.hasCourses;
-      expect(preSelectors).toEqual([appSelectors.numCourses]);
-      expect(cb(3)).toEqual(true);
-      expect(cb(0)).toEqual(false);
-    });
-  });
-  describe('showSelectSessionModal', () => {
-    it('returns true if the selectSessionModal cardId is not null', () => {
-      const { preSelectors, cb } = appSelectors.showSelectSessionModal;
-      expect(preSelectors).toEqual([simpleSelectors.selectSessionModal]);
-      expect(cb({ cardId: 'test' })).toEqual(true);
-      expect(cb({ data: 'test' })).toEqual(false);
-    });
-  });
-});
diff --git a/src/data/redux/app/selectors/courseCard.js b/src/data/redux/app/selectors/courseCard.js
deleted file mode 100644
index aba3deb0c..000000000
--- a/src/data/redux/app/selectors/courseCard.js
+++ /dev/null
@@ -1,155 +0,0 @@
-import { StrictDict } from 'utils';
-import { baseAppUrl } from 'data/services/lms/urls';
-import { EXECUTIVE_EDUCATION_COURSE_MODES } from 'data/constants/course';
-
-import * as module from './courseCard';
-import * as simpleSelectors from './simpleSelectors';
-
-const { cardSimpleSelectors, mkCardSelector } = simpleSelectors;
-
-const today = new Date();
-const dateSixMonthsFromNow = new Date();
-dateSixMonthsFromNow.setDate(dateSixMonthsFromNow.getDate() + 180);
-
-export const loadDateVal = (date) => (date ? new Date(date) : null);
-
-export const courseCard = StrictDict({
-  certificate: mkCardSelector(
-    cardSimpleSelectors.certificate,
-    (certificate) => (certificate === null ? {} : ({
-      availableDate: new Date(certificate.availableDate),
-      certPreviewUrl: baseAppUrl(certificate.certPreviewUrl),
-      isDownloadable: certificate.isDownloadable,
-      isEarnedButUnavailable: certificate.isEarned && new Date(certificate.availableDate) > new Date(),
-      isRestricted: certificate.isRestricted,
-      isEarned: certificate.isEarned,
-    })),
-  ),
-  course: mkCardSelector(
-    cardSimpleSelectors.course,
-    (course) => ({
-      bannerImgSrc: baseAppUrl(course.bannerImgSrc),
-      courseNumber: course.courseNumber,
-      courseName: course.courseName,
-      socialShareUrl: course.socialShareUrl,
-    }),
-  ),
-  courseProvider: mkCardSelector(
-    cardSimpleSelectors.courseProvider,
-    (courseProvider) => ({ name: courseProvider?.name }),
-  ),
-  courseRun: mkCardSelector(
-    cardSimpleSelectors.courseRun,
-    (courseRun) => (courseRun === null ? {} : {
-      endDate: module.loadDateVal(courseRun.endDate),
-      startDate: module.loadDateVal(courseRun.startDate),
-      advertisedStart: courseRun.advertisedStart,
-
-      courseId: courseRun.courseId,
-      isArchived: courseRun.isArchived,
-      isStarted: courseRun.isStarted,
-
-      minPassingGrade: Math.floor(courseRun.minPassingGrade * 100),
-
-      homeUrl: courseRun.homeUrl,
-      marketingUrl: courseRun.marketingUrl,
-
-      progressUrl: baseAppUrl(courseRun.progressUrl),
-      resumeUrl: baseAppUrl(courseRun.resumeUrl), // resume will route this to learning mfe.
-      unenrollUrl: baseAppUrl(courseRun.unenrollUrl),
-    }),
-  ),
-  credit: mkCardSelector(
-    cardSimpleSelectors.credit,
-    (credit) => {
-      if (!credit || Object.keys(credit).length === 0) {
-        return { isEligible: false };
-      }
-      return {
-        isEligible: true,
-        providerStatusUrl: credit.providerStatusUrl,
-        providerName: credit.providerName,
-        providerId: credit.providerId,
-        error: credit.error,
-        purchased: credit.purchased,
-        requestStatus: credit.requestStatus,
-      };
-    },
-  ),
-  enrollment: mkCardSelector(
-    cardSimpleSelectors.enrollment,
-    (enrollment) => {
-      if (enrollment == null) {
-        return { isEnrolled: false };
-      }
-      const { isStaff, hasUnmetPrereqs, isTooEarly } = enrollment.coursewareAccess;
-      return {
-        coursewareAccess: enrollment.coursewareAccess,
-        hasAccess: isStaff || !(hasUnmetPrereqs || isTooEarly),
-        isEnrolled: enrollment.isEnrolled,
-        lastEnrolled: enrollment.lastEnrolled,
-        hasStarted: enrollment.hasStarted,
-
-        accessExpirationDate: module.loadDateVal(enrollment.accessExpirationDate),
-        canUpgrade: enrollment.canUpgrade,
-        isAudit: enrollment.isAudit,
-        isAuditAccessExpired: enrollment.isAuditAccessExpired,
-        isVerified: enrollment.isVerified,
-
-        isEmailEnabled: enrollment.isEmailEnabled,
-        hasOptedOutOfEmail: enrollment.hasOptedOutOfEmail,
-        mode: enrollment.mode,
-        isExecEd2UCourse: EXECUTIVE_EDUCATION_COURSE_MODES.includes(enrollment.mode),
-      };
-    },
-  ),
-  entitlement: mkCardSelector(
-    cardSimpleSelectors.entitlement,
-    (entitlement) => {
-      if (!entitlement || Object.keys(entitlement).length === 0) {
-        return { isEntitlement: false };
-      }
-      const deadline = new Date(entitlement.changeDeadline);
-      const deadlinePassed = deadline < today;
-      const showExpirationWarning = (
-        !entitlement.isFulfilled
-        && !deadlinePassed
-        && deadline <= dateSixMonthsFromNow
-      );
-      return {
-        isEntitlement: true,
-
-        availableSessions: entitlement.availableSessions,
-        changeDeadline: deadline,
-        isExpired: entitlement.isExpired,
-        isFulfilled: entitlement.isFulfilled,
-        uuid: entitlement.uuid,
-
-        hasSessions: entitlement.availableSessions?.length > 0,
-        canChange: !deadlinePassed,
-        showExpirationWarning,
-      };
-    },
-  ),
-  gradeData: mkCardSelector(
-    cardSimpleSelectors.gradeData,
-    (gradeData) => ({ isPassing: gradeData.isPassing }),
-  ),
-  relatedPrograms: mkCardSelector(
-    cardSimpleSelectors.relatedPrograms,
-    (relatedPrograms) => ({
-      list: relatedPrograms.map(program => ({
-        bannerImgSrc: program.bannerImgSrc,
-        logoImgSrc: program.logoImgSrc,
-        numberOfCourses: program.numberOfCourses,
-        programType: program.programType,
-        programUrl: program.programUrl,
-        provider: program.provider,
-        title: program.title,
-      })),
-      length: relatedPrograms.length,
-    }),
-  ),
-});
-
-export default courseCard;
diff --git a/src/data/redux/app/selectors/courseCard.test.js b/src/data/redux/app/selectors/courseCard.test.js
deleted file mode 100644
index 79edc57e1..000000000
--- a/src/data/redux/app/selectors/courseCard.test.js
+++ /dev/null
@@ -1,398 +0,0 @@
-import { keyStore } from 'utils';
-import { baseAppUrl } from 'data/services/lms/urls';
-import { EXECUTIVE_EDUCATION_COURSE_MODES } from 'data/constants/course';
-
-import simpleSelectors from './simpleSelectors';
-import * as module from './courseCard';
-
-jest.mock('data/services/lms/urls', () => ({
-  baseAppUrl: url => ({ baseAppUrl: url }),
-}));
-
-jest.mock('./simpleSelectors', () => ({
-  mkCardSelector: (simpleSelector, selector) => ({
-    mkCardSelector: { selector, simpleSelector },
-  }),
-  cardSimpleSelectors: jest.requireActual('./simpleSelectors').cardSimpleSelectors,
-}));
-
-const { courseCard } = module;
-const { cardSimpleSelectors } = simpleSelectors;
-
-const moduleKeys = keyStore(module);
-
-let testData;
-let selector;
-let simpleSelector;
-let selected;
-
-const dates = {
-  today: new Date(),
-  tomorrow: new Date(),
-  nextYear: new Date(),
-  yesterday: new Date(),
-};
-dates.tomorrow.setDate(dates.tomorrow.getDate() + 1);
-dates.nextYear.setDate(dates.nextYear.getDate() + 365);
-dates.yesterday.setDate(dates.yesterday.getDate() - 1);
-
-/*
- * Takes a selector as input and fetches the referenced selector and simpleSelector for
- * the selector to be tested, to be stored in global variables.
- * Also sets `selected` global variable is loaded with the passed data, which is stored
- * as `testData`.
- */
-const loadSelector = (sel, data) => {
-  ({ simpleSelector, selector } = sel.mkCardSelector);
-  testData = data;
-  selected = selector(data);
-};
-
-describe('courseCard selectors module', () => {
-  describe('loadDateVal helper function', () => {
-    it('returns passed date value converted to Date', () => {
-      const testDate = '2000-10-10';
-      expect(module.loadDateVal(testDate)).toEqual(new Date(testDate));
-    });
-    it('returns null if no value is passed', () => {
-      expect(module.loadDateVal()).toEqual(null);
-    });
-  });
-  describe('courseCard selectors', () => {
-    let dateSpy;
-    beforeEach(() => {
-      dateSpy = jest.spyOn(module, moduleKeys.loadDateVal);
-      dateSpy.mockImplementation(v => new Date(v));
-    });
-    afterEach(() => {
-      dateSpy.mockRestore();
-    });
-    describe('certificate selector', () => {
-      beforeEach(() => {
-        loadSelector(courseCard.certificate, {
-          certPreviewUrl: 'test-cert-preview-url',
-          isDownloadable: 'test-is-downloadable',
-          isRestricted: 'test-is-restricted',
-          isEarned: false,
-          availableDate: '2020-10-10',
-        });
-      });
-      it('returns a card selector based on certificate cardSimpleSelector', () => {
-        expect(simpleSelector).toEqual(cardSimpleSelectors.certificate);
-      });
-      it('returns {} object if null certificate received', () => {
-        expect(selector(null)).toEqual({});
-      });
-      it('passes availableDate, converted to a date', () => {
-        expect(selected.availableDate).toMatchObject(new Date(testData.availableDate));
-      });
-      it('passes [isDownloadable, isRestricted]', () => {
-        expect(selected.isDownloadable).toEqual(testData.isDownloadable);
-        expect(selected.isRestricted).toEqual(testData.isRestricted);
-      });
-      it('passes certPreviewUrl as app url', () => {
-        expect(selected.certPreviewUrl).toEqual(baseAppUrl(testData.certPreviewUrl));
-      });
-      describe('isEarnedButUnavailable', () => {
-        it('passes true iff certificate is earned but availableDate is in the future', () => {
-          const testSelector = (data, expected) => {
-            expect(selector({ ...testData, ...data }).isEarnedButUnavailable).toEqual(expected);
-          };
-          testSelector({ isEarned: true, availableDate: dates.today }, false);
-          testSelector({ isEarned: true, availableDate: dates.yesterday }, false);
-          testSelector({ isEarned: true, availableDate: dates.tomorrow }, true);
-          testSelector({ isEarned: false, availableDate: dates.tomorrow }, false);
-        });
-      });
-    });
-    describe('course selector', () => {
-      beforeEach(() => {
-        loadSelector(courseCard.course, {
-          bannerImgSrc: 'test-banner-img-src',
-          courseNumber: 'test-course-number',
-          courseName: 'test-course-name',
-          socialShareUrl: 'test-social-share-url',
-        });
-      });
-      it('returns a card selector based on course cardSimpleSelector', () => {
-        expect(simpleSelector).toEqual(cardSimpleSelectors.course);
-      });
-      it('passes bannerImgSrc, converted to a baseAppUrl', () => {
-        expect(selected.bannerImgSrc).toEqual(baseAppUrl(testData.bannerImgSrc));
-      });
-      it('passes [courseNumber, courseName, socialShareUrl]', () => {
-        expect(selected.courseNumber).toEqual(testData.courseNumber);
-        expect(selected.courseName).toEqual(testData.courseName);
-        expect(selected.socialShareUrl).toEqual(testData.socialShareUrl);
-      });
-    });
-    describe('courseProvider selector', () => {
-      beforeEach(() => {
-        loadSelector(courseCard.courseProvider, { name: 'test-provider-name' });
-      });
-      it('returns a card selector based on courseProvider cardSimpleSelector', () => {
-        expect(simpleSelector).toEqual(cardSimpleSelectors.courseProvider);
-      });
-      describe('name', () => {
-        it('passes the provider name if provider is known', () => {
-          expect(selected.name).toEqual(testData.name);
-        });
-        it('passes undefined if provider is not known', () => {
-          expect(selector().name).toEqual(undefined);
-        });
-      });
-    });
-    describe('courseRun selector', () => {
-      beforeEach(() => {
-        loadSelector(courseCard.courseRun, {
-          endDate: '3000-10-20',
-          startDate: '2000-10-20',
-          advertisedStart: 'Mid June',
-
-          courseId: 'test-course-id',
-          isArchived: 'test-is-archived',
-          isStarted: 'test-is-started',
-
-          minPassingGrade: 0.9354,
-
-          homeUrl: 'test-home-url',
-          marketingUrl: 'test-marketing-url',
-
-          progressUrl: 'test-progress-url',
-          resumeUrl: 'test-resume-url',
-          unenrollUrl: 'test-unenroll-url',
-        });
-      });
-      it('returns a card selector based on courseRun cardSimpleSelector', () => {
-        expect(simpleSelector).toEqual(cardSimpleSelectors.courseRun);
-      });
-      it('returns {} object if null courseRun received', () => {
-        expect(selector(null)).toEqual({});
-      });
-      it('passes [endDate, startDate], converted to dates', () => {
-        expect(selected.endDate).toEqual(new Date(testData.endDate));
-        expect(selected.startDate).toEqual(new Date(testData.startDate));
-      });
-      it('passes advertised start date', () => {
-        expect(selected.advertisedStart).toEqual(testData.advertisedStart);
-      });
-      it('passes [courseId, isArchived, isStarted]', () => {
-        expect(selected.courseId).toEqual(testData.courseId);
-        expect(selected.isArchived).toEqual(testData.isArchived);
-        expect(selected.isStarted).toEqual(testData.isStarted);
-      });
-      it('passes minPassingGrade floored from float to a percentage value', () => {
-        expect(selected.minPassingGrade).toEqual(93);
-      });
-      it('passes [homeUrl, marketingUrl]', () => {
-        expect(selected.homeUrl).toEqual(testData.homeUrl);
-        expect(selected.marketingUrl).toEqual(testData.marketingUrl);
-      });
-      it('passes [progressUrl, unenrollUrl, resumeUrl], converted to baseAppUrl', () => {
-        expect(selected.progressUrl).toEqual(baseAppUrl(testData.progressUrl));
-        expect(selected.resumeUrl).toEqual(baseAppUrl(testData.resumeUrl));
-        expect(selected.unenrollUrl).toEqual(baseAppUrl(testData.unenrollUrl));
-      });
-    });
-    describe('credit selector', () => {
-      const credit = {
-        providerStatusUrl: 'test-provider-status-url',
-        providerName: 'test-provider-name',
-        providerId: 'test-provider-id',
-        error: 'test-provider-id',
-        purchased: 'test-purchased',
-        requestStatus: 'test-request-status',
-      };
-      it('returns a card selector based on credit cardSimpleSelector', () => {
-        loadSelector(courseCard.credit, {});
-        expect(simpleSelector).toEqual(cardSimpleSelectors.credit);
-      });
-      it('returns { isEligible: false } if empty object received for credit', () => {
-        loadSelector(courseCard.credit, {});
-        expect(selected).toEqual({ isEligible: false });
-      });
-      describe('credit fields when credit object is passed', () => {
-        beforeEach(() => {
-          loadSelector(courseCard.credit, credit);
-        });
-        it('returns isEligible: true', () => {
-          expect(selected.isEligible).toEqual(true);
-        });
-        it('returns provider status url, name, and id', () => {
-          expect(selected.providerStatusUrl).toEqual(credit.providerStatusUrl);
-          expect(selected.providerName).toEqual(credit.providerName);
-          expect(selected.providerId).toEqual(credit.providerId);
-        });
-        it('returns error, purchased and requestStatus fields', () => {
-          expect(selected.error).toEqual(credit.error);
-          expect(selected.purchased).toEqual(credit.purchased);
-          expect(selected.requestStatus).toEqual(credit.requestStatus);
-        });
-      });
-    });
-    describe('enrollment selector', () => {
-      const defaultData = {
-        coursewareAccess: {
-          isStaff: false,
-          hasUnmetPrereqs: false,
-          isTooEarly: false,
-        },
-        isEnrolled: 'test-is-enrolled',
-        lastEnrolled: 'test-last-enrolled',
-        hasStarted: 'test-has-started',
-        accessExpirationDate: '3000-10-20',
-        canUpgrade: 'test-can-upgrade',
-        isAudit: 'test-is-audit',
-        isAuditAccessExpired: 'test-is-audit-access-expired',
-        isVerified: 'test-is-verified',
-        isEmailEnabled: 'test-is-email-enabled',
-        mode: 'default',
-      };
-      beforeEach(() => {
-        loadSelector(courseCard.enrollment, defaultData);
-      });
-      it('returns a card selector based on enrollment cardSimpleSelector', () => {
-        expect(simpleSelector).toEqual(cardSimpleSelectors.enrollment);
-      });
-      it('returns { isEnrolled: false } object if null enrollment received', () => {
-        expect(selector(null)).toEqual({ isEnrolled: false });
-      });
-      it('passes [coursewareAccess, hasStarted, isEnrolled, lastEnrolled]', () => {
-        expect(selected.coursewareAccess).toEqual(testData.coursewareAccess);
-        expect(selected.hasStarted).toEqual(testData.hasStarted);
-        expect(selected.isEnrolled).toEqual(testData.isEnrolled);
-        expect(selected.lastEnrolled).toEqual(testData.lastEnrolled);
-      });
-      it('passes hasAccess if staff or neither has umet prereqs nor is too early', () => {
-        const testAccess = (access, expected) => {
-          expect(selector({ ...testData, coursewareAccess: access }).hasAccess).toEqual(expected);
-        };
-        testAccess({ isStaff: false, hasUnmetPrereqs: false, isTooEarly: false }, true);
-        testAccess({ isStaff: false, hasUnmetPrereqs: false, isTooEarly: true }, false);
-        testAccess({ isStaff: false, hasUnmetPrereqs: true, isTooEarly: false }, false);
-        testAccess({ isStaff: false, hasUnmetPrereqs: true, isTooEarly: true }, false);
-        testAccess({ isStaff: true, hasUnmetPrereqs: true, isTooEarly: true }, true);
-      });
-      it('passes accessExpirationDate, converted to date', () => {
-        expect(selected.accessExpirationDate).toEqual(new Date(testData.accessExpirationDate));
-      });
-      it('passes [canUpgrade, isAudit, isAuditAccessExpired, isVerified]', () => {
-        expect(selected.canUpgrade).toEqual(testData.canUpgrade);
-        expect(selected.isAudit).toEqual(testData.isAudit);
-        expect(selected.isAuditAccessExpired).toEqual(testData.isAuditAccessExpired);
-        expect(selected.isVerified).toEqual(testData.isVerified);
-      });
-      it('passes isEmailEnabled', () => {
-        expect(selected.isEmailEnabled).toEqual(testData.isEmailEnabled);
-      });
-      it('returns isExecEd2UCourse: false if mode is not in EXECUTIVE_EDUCATION_COURSE_MODES', () => {
-        expect(selected.isExecEd2UCourse).toEqual(false);
-      });
-      it('returns isExecEd2UCourse: true if mode is in EXECUTIVE_EDUCATION_COURSE_MODES', () => {
-        loadSelector(courseCard.enrollment, { ...defaultData, mode: EXECUTIVE_EDUCATION_COURSE_MODES[0] });
-        expect(selected.isExecEd2UCourse).toEqual(true);
-      });
-    });
-    describe('entitlement selector', () => {
-      beforeEach(() => {
-        loadSelector(courseCard.entitlement, {
-          availableSessions: ['test', 'sessions'],
-          changeDeadline: '2000-10-20',
-          isExpired: 'test-is-expired',
-          isFulfilled: 'test-is-fulfilled',
-          uuid: 'test-uuid',
-        });
-      });
-      it('returns a card selector based on entilement cardSimpleSelector', () => {
-        expect(simpleSelector).toEqual(cardSimpleSelectors.entitlement);
-      });
-      it('returns { isEntilement: false } if entitlement object is missing or empty', () => {
-        expect(selector({})).toEqual({ isEntitlement: false });
-        expect(selector()).toEqual({ isEntitlement: false });
-      });
-      it('passes isEntitlement: true for entilement data', () => {
-        expect(selected.isEntitlement).toEqual(true);
-      });
-      it('passes [availableSessions, isExpired, isFulfilled, uuid]', () => {
-        expect(selected.availableSessions).toEqual(testData.availableSessions);
-        expect(selected.isExpired).toEqual(testData.isExpired);
-        expect(selected.isFulfilled).toEqual(testData.isFulfilled);
-        expect(selected.uuid).toEqual(testData.uuid);
-      });
-      it('passess changeDeadline as changeDeadline, converted to a date', () => {
-        expect(selected.changeDeadline).toEqual(new Date(testData.changeDeadline));
-      });
-      it('passes hasSessions if availableSessions is provided and has a length > 0', () => {
-        expect(selected.hasSessions).toEqual(true);
-        expect(selector({ ...testData, availableSessions: [] }).hasSessions).toEqual(false);
-      });
-      it('passes canChange if the deadline is not before current date', () => {
-        expect(selector({ ...testData, changeDeadline: dates.yesterday }).canChange).toEqual(false);
-        expect(selector({ ...testData, changeDeadline: dates.tomorrow }).canChange).toEqual(true);
-      });
-      it('passes showExpirationWarning if the deadline is 0-6 months in the future and not fulfilled', () => {
-        const testSelector = ({ isFulfilled, changeDeadline }, expected) => {
-          expect(
-            selector({ ...testData, isFulfilled, changeDeadline }).showExpirationWarning,
-          ).toEqual(expected);
-        };
-        testSelector({ isFulfilled: false, changeDeadline: dates.yesterday }, false);
-        testSelector({ isFulfilled: false, changeDeadline: dates.tomorrow }, true);
-        testSelector({ isFulfilled: false, changeDeadline: dates.nextYear }, false);
-        testSelector({ isFulfilled: true, changeDeadline: dates.nextYear }, false);
-      });
-    });
-    describe('gradeData selector', () => {
-      beforeEach(() => {
-        loadSelector(courseCard.gradeData, { isPassing: 'test-is-passing' });
-      });
-      it('returns a card selector based on gradeData cardSimpleSelector', () => {
-        expect(simpleSelector).toEqual(cardSimpleSelectors.gradeData);
-      });
-      it('passes isPassing', () => {
-        expect(selected.isPassing).toEqual(testData.isPassing);
-      });
-    });
-    describe('relatedPrograms selector', () => {
-      beforeEach(() => {
-        const programData = (index) => ({
-          bannerImgSrc: `test-banner-img-src-${index}`,
-          logoImgSrc: `test-logo-img-src-${index}`,
-          numberOfCourses: `test-number-of-courses-${index}`,
-          programType: `test-program-type-${index}`,
-          programUrl: `test-program-url-${index}`,
-          provider: `test-provider-${index}`,
-          title: `test-title-${index}`,
-        });
-        loadSelector(courseCard.relatedPrograms, [
-          programData(0),
-          programData(1),
-          programData(2),
-          programData(3),
-          programData(4),
-        ]);
-      });
-      it('returns a card selector based on relatedPrograms cardSimpleSelector', () => {
-        expect(simpleSelector).toEqual(cardSimpleSelectors.relatedPrograms);
-      });
-      it('passes [bannerImgSrc, logoImgSrc] for each program', () => {
-        selected.list.forEach((row, i) => {
-          expect(row.bannerImgSrc).toEqual(testData[i].bannerImgSrc);
-          expect(row.logoImgSrc).toEqual(testData[i].logoImgSrc);
-        });
-      });
-      it('passes [numberOfCourses, programType, programUrl, provider, title] for each', () => {
-        selected.list.forEach((row, i) => {
-          expect(row.numberOfCourses).toEqual(testData[i].numberOfCourses);
-          expect(row.programType).toEqual(testData[i].programType);
-          expect(row.programUrl).toEqual(testData[i].programUrl);
-          expect(row.provider).toEqual(testData[i].provider);
-          expect(row.title).toEqual(testData[i].title);
-        });
-      });
-      it('passes number of programs a length', () => {
-        expect(selected.length).toEqual(testData.length);
-      });
-    });
-  });
-});
diff --git a/src/data/redux/app/selectors/currentList.js b/src/data/redux/app/selectors/currentList.js
deleted file mode 100644
index 9c713eb63..000000000
--- a/src/data/redux/app/selectors/currentList.js
+++ /dev/null
@@ -1,58 +0,0 @@
-import { StrictDict } from 'utils';
-import { FilterKeys, SortKeys } from 'data/constants/app';
-
-import simpleSelectors from './simpleSelectors';
-import * as module from './currentList';
-
-export const sortFn = (transform, { reverse }) => (v1, v2) => {
-  const [a, b] = [v1, v2].map(transform);
-  if (a === b) { return 0; }
-  return ((a > b) ? 1 : -1) * (reverse ? -1 : 1);
-};
-
-export const courseFilters = StrictDict({
-  [FilterKeys.notEnrolled]: (course) => !course.enrollment.isEnrolled,
-  [FilterKeys.done]: (course) => course.courseRun !== null && course.courseRun.isArchived,
-  [FilterKeys.upgraded]: (course) => course.enrollment.isVerified,
-  [FilterKeys.inProgress]: (course) => course.enrollment.hasStarted,
-  [FilterKeys.notStarted]: (course) => !course.enrollment.hasStarted,
-});
-
-export const transforms = StrictDict({
-  [SortKeys.enrolled]: ({ enrollment }) => new Date(enrollment.lastEnrolled),
-  [SortKeys.title]: ({ course }) => course.courseName.toLowerCase(),
-});
-
-export const courseFilterFn = filters => (filters.length
-  ? course => filters.reduce((match, filter) => match && courseFilters[filter](course), true)
-  : () => true);
-
-export const currentList = (allCourses, {
-  sortBy,
-  filters,
-}) => allCourses
-  .filter(module.courseFilterFn(filters))
-  .sort(module.sortFn(transforms[sortBy], { reverse: sortBy === SortKeys.enrolled }));
-
-export const visibleList = (state, {
-  sortBy,
-  filters,
-  pageSize,
-}) => {
-  const courses = Object.values(simpleSelectors.courseData(state));
-  const list = module.currentList(courses, { sortBy, filters });
-  const pageNumber = simpleSelectors.pageNumber(state);
-
-  if (pageSize === 0) {
-    return {
-      visible: list,
-      numPages: 1,
-    };
-  }
-  return {
-    visibleList: list.slice((pageNumber - 1) * pageSize, pageNumber * pageSize),
-    numPages: Math.ceil(list.length / pageSize),
-  };
-};
-
-export default visibleList;
diff --git a/src/data/redux/app/selectors/currentList.test.js b/src/data/redux/app/selectors/currentList.test.js
deleted file mode 100644
index 058d5619c..000000000
--- a/src/data/redux/app/selectors/currentList.test.js
+++ /dev/null
@@ -1,185 +0,0 @@
-import { keyStore } from 'utils';
-import { FilterKeys, SortKeys } from 'data/constants/app';
-import simpleSelectors from './simpleSelectors';
-import * as module from './currentList';
-
-jest.mock('./simpleSelectors', () => ({
-  __esModule: true,
-  default: {
-    courseData: jest.fn(),
-    pageNumber: jest.fn(),
-  },
-}));
-
-const {
-  sortFn,
-  courseFilters,
-  transforms,
-  courseFilterFn,
-  currentList,
-  visibleList,
-} = module;
-
-const moduleKeys = keyStore(module);
-
-const testDate = '2000-10-10';
-const testString = 'test-STRING';
-
-describe('courseList selector module', () => {
-  describe('utilities', () => {
-    describe('sortFn', () => {
-      it('performs comparison sort after running both values through transform', () => {
-        const transform = ({ val }) => val;
-        expect(sortFn(transform, { reverse: false })({ val: 2 }, { val: 1 })).toEqual(1);
-        expect(sortFn(transform, { reverse: false })({ val: 1 }, { val: 1 })).toEqual(0);
-        expect(sortFn(transform, { reverse: false })({ val: 1 }, { val: 2 })).toEqual(-1);
-        expect(sortFn(transform, { reverse: true })({ val: 2 }, { val: 1 })).toEqual(-1);
-        expect(sortFn(transform, { reverse: true })({ val: 1 }, { val: 1 })).toEqual(0);
-        expect(sortFn(transform, { reverse: true })({ val: 1 }, { val: 2 })).toEqual(1);
-      });
-    });
-    describe('courseFilters', () => {
-      let filterFn;
-      test('notEnrolled returns true iff course is not enrolled', () => {
-        filterFn = courseFilters[FilterKeys.notEnrolled];
-        expect(filterFn({ enrollment: { isEnrolled: true } })).toEqual(false);
-        expect(filterFn({ enrollment: { isEnrolled: false } })).toEqual(true);
-      });
-      test('done returns true iff learner has finished course', () => {
-        filterFn = courseFilters[FilterKeys.done];
-        expect(filterFn({ courseRun: null })).toEqual(false);
-        expect(filterFn({ courseRun: { isArchived: true } })).toEqual(true);
-        expect(filterFn({ courseRun: { isArchived: false } })).toEqual(false);
-      });
-      test('upgraded returns true if learner is verified', () => {
-        filterFn = courseFilters[FilterKeys.upgraded];
-        expect(filterFn({ enrollment: { isVerified: true } })).toEqual(true);
-        expect(filterFn({ enrollment: { isVerified: false } })).toEqual(false);
-      });
-      test('inProgress returns true iff learner has started course', () => {
-        filterFn = courseFilters[FilterKeys.inProgress];
-        expect(filterFn({ enrollment: { hasStarted: true } })).toEqual(true);
-        expect(filterFn({ enrollment: { hasStarted: false } })).toEqual(false);
-      });
-      test('notStarted returns true iff learner has not started course', () => {
-        filterFn = courseFilters[FilterKeys.notStarted];
-        expect(filterFn({ enrollment: { hasStarted: true } })).toEqual(false);
-        expect(filterFn({ enrollment: { hasStarted: false } })).toEqual(true);
-      });
-    });
-    describe('transforms', () => {
-      test('enrolled transform returns date transform of enrollment.lastEnrolled', () => {
-        const data = { enrollment: { lastEnrolled: testDate } };
-        expect(transforms[SortKeys.enrolled](data)).toEqual(new Date(testDate));
-      });
-      test('title transform returns lowercase transform of course.courseName', () => {
-        const data = { course: { courseName: testString } };
-        expect(transforms[SortKeys.title](data)).toEqual(testString.toLowerCase());
-      });
-    });
-    describe('courseFilterFn', () => {
-      it('returns always-true filter if filter list is empty', () => {
-        expect(courseFilterFn([])()).toEqual(true);
-      });
-      it('takes filters and then course, and returns true if course matches all filters', () => {
-        const filters = [FilterKeys.inProgress, FilterKeys.upgraded];
-        const inProgressSpy = jest.spyOn(courseFilters, FilterKeys.inProgress);
-        const upgradedSpy = jest.spyOn(courseFilters, FilterKeys.upgraded);
-        inProgressSpy.mockImplementation(v => v > 3);
-        upgradedSpy.mockImplementation(v => v > 5);
-
-        expect(courseFilterFn(filters)(6)).toEqual(true);
-        expect(courseFilterFn(filters)(5)).toEqual(false);
-        upgradedSpy.mockImplementation(v => v > 2);
-        expect(courseFilterFn(filters)(3)).toEqual(false);
-
-        inProgressSpy.mockRestore();
-        upgradedSpy.mockRestore();
-      });
-    });
-    describe('currentList selector', () => {
-      it('returns passed courses filtered and sorted', () => {
-        const sortSpy = jest.spyOn(module, moduleKeys.sortFn);
-        const filterSpy = jest.spyOn(module, moduleKeys.courseFilterFn);
-        filterSpy.mockReturnValue(({ val }) => val > 0);
-        sortSpy.mockReturnValue((v1, v2) => {
-          const [a, b] = [v1, v2].map(({ val }) => val);
-          if (a === b) { return 0; }
-          return (a > b) ? 1 : -1;
-        });
-        const testCourses = {
-          empty: { val: 0 },
-          v1: { val: 1 },
-          v2: { val: 2 },
-          v3: { val: 3 },
-        };
-        const {
-          empty,
-          v1,
-          v2,
-          v3,
-        } = testCourses;
-        let sortBy = SortKeys.enrolled;
-        const testFilters = [1, 2, 3];
-        expect(currentList(
-          [empty, v2, v1, empty, empty, v3, empty],
-          { sortBy, filters: testFilters },
-        )).toEqual([v1, v2, v3]);
-        expect(sortSpy).toHaveBeenCalledWith(transforms[sortBy], { reverse: true });
-        expect(filterSpy).toHaveBeenCalledWith(testFilters);
-
-        sortSpy.mockClear();
-        sortBy = SortKeys.title;
-        expect(currentList(
-          [empty, v2, v1, empty, empty, v3, empty],
-          { sortBy, filters: testFilters },
-        )).toEqual([v1, v2, v3]);
-        expect(sortSpy).toHaveBeenCalledWith(transforms[sortBy], { reverse: false });
-        expect(filterSpy).toHaveBeenCalledWith(testFilters);
-        sortSpy.mockRestore();
-        filterSpy.mockRestore();
-      });
-    });
-  });
-  describe('visibleList selector', () => {
-    let listSpy;
-    let out;
-    const pageSize = 2;
-    const pageNumber = 3;
-    const testState = { some: 'state' };
-    const sortBy = SortKeys.enrolled;
-    const testFilters = [1, 2, 3];
-    const testCourseData = { test: 'course-data' };
-    const testList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
-    beforeEach(() => {
-      listSpy = jest.spyOn(module, moduleKeys.currentList);
-      listSpy.mockReturnValue(testList);
-      simpleSelectors.courseData.mockReturnValue(testCourseData);
-      simpleSelectors.pageNumber.mockReturnValue(pageNumber);
-      out = visibleList(testState, { sortBy, filters: testFilters, pageSize });
-    });
-    afterEach(() => {
-      listSpy.mockRestore();
-    });
-    it('loads currentList from courseData values and passed sortBy and filters values', () => {
-      expect(simpleSelectors.courseData).toHaveBeenCalledWith(testState);
-      expect(simpleSelectors.pageNumber).toHaveBeenCalledWith(testState);
-      expect(listSpy).toHaveBeenCalledWith(
-        Object.values(testCourseData),
-        { sortBy, filters: testFilters },
-      );
-    });
-    it('returns visible page based on passed page size and stored pageNumber', () => {
-      // page 3, 2 per page. [0 1] [2 3] [4 5] ...
-      expect(out.visibleList).toEqual([testList[4], testList[5]]);
-    });
-    it('returns number of pages based on page size and list length', () => {
-      expect(out.numPages).toEqual(6);
-    });
-    it('disable pagination if page size is 0', () => {
-      out = visibleList(testState, { sortBy, filters: testFilters, pageSize: 0 });
-      expect(out.visible).toEqual(testList);
-      expect(out.numPages).toEqual(1);
-    });
-  });
-});
diff --git a/src/data/redux/app/selectors/index.js b/src/data/redux/app/selectors/index.js
deleted file mode 100644
index a2cc58175..000000000
--- a/src/data/redux/app/selectors/index.js
+++ /dev/null
@@ -1,13 +0,0 @@
-import { StrictDict } from 'utils';
-
-import simpleSelectors from './simpleSelectors';
-import appSelectors from './appSelectors';
-import courseCard from './courseCard';
-import currentList from './currentList';
-
-export default StrictDict({
-  ...simpleSelectors,
-  ...appSelectors,
-  courseCard,
-  currentList,
-});
diff --git a/src/data/redux/app/selectors/simpleSelectors.js b/src/data/redux/app/selectors/simpleSelectors.js
deleted file mode 100644
index 0c576fc28..000000000
--- a/src/data/redux/app/selectors/simpleSelectors.js
+++ /dev/null
@@ -1,38 +0,0 @@
-import { createSelector } from 'reselect';
-import { StrictDict } from 'utils';
-
-import * as module from './simpleSelectors';
-
-export const appSelector = (state) => state.app;
-const mkSimpleSelector = (cb) => createSelector([module.appSelector], cb);
-
-// top-level app data selectors
-export const simpleSelectors = StrictDict({
-  courseData: mkSimpleSelector(app => app.courseData),
-  platformSettings: mkSimpleSelector(app => app.platformSettings),
-  suggestedCourses: mkSimpleSelector(app => app.suggestedCourses),
-  emailConfirmation: mkSimpleSelector(app => app.emailConfirmation),
-  enterpriseDashboard: mkSimpleSelector(app => app.enterpriseDashboard || {}),
-  selectSessionModal: mkSimpleSelector(app => app.selectSessionModal),
-  pageNumber: mkSimpleSelector(app => app.pageNumber),
-  filters: mkSimpleSelector(app => app.filters),
-  socialShareSettings: mkSimpleSelector(app => app.socialShareSettings),
-});
-
-export const cardSimpleSelectors = StrictDict({
-  certificate: ({ certificate }) => certificate,
-  course: ({ course }) => course,
-  courseProvider: ({ courseProvider }) => courseProvider,
-  courseRun: ({ courseRun }) => courseRun,
-  credit: ({ credit }) => credit,
-  enrollment: ({ enrollment }) => enrollment,
-  entitlement: ({ entitlement }) => entitlement,
-  gradeData: ({ gradeData }) => gradeData,
-  relatedPrograms: ({ programs: { relatedPrograms } }) => relatedPrograms,
-});
-
-export const mkCardSelector = (simpleSelector, selector) => (state, cardId) => (
-  selector(simpleSelector(module.simpleSelectors.courseData(state)[cardId]))
-);
-
-export default simpleSelectors;
diff --git a/src/data/redux/app/selectors/simpleSelectors.test.js b/src/data/redux/app/selectors/simpleSelectors.test.js
deleted file mode 100644
index 7d9a8dbed..000000000
--- a/src/data/redux/app/selectors/simpleSelectors.test.js
+++ /dev/null
@@ -1,75 +0,0 @@
-import { keyStore } from 'utils';
-import * as module from './simpleSelectors';
-
-const {
-  appSelector,
-  simpleSelectors,
-  cardSimpleSelectors,
-  mkCardSelector,
-} = module;
-
-let keys;
-let testData;
-
-let testState;
-const testString = 'test-STRING';
-const testCardId = 'testCARD-id';
-
-describe('app simple selectors', () => {
-  describe('base app selector', () => {
-  });
-  describe('simple selectors', () => {
-    keys = keyStore(simpleSelectors);
-    test.each([
-      keys.courseData,
-      keys.platformSettings,
-      keys.suggestedCourses,
-      keys.emailConfirmation,
-      keys.enterpriseDashboard,
-      keys.selectSessionModal,
-      keys.pageNumber,
-      keys.socialShareSettings,
-      keys.filters,
-    ])('%s app simple selector forwards corresponding data from app store', (key) => {
-      testState = { app: { [key]: testString, otherField: 'fake string' } };
-      const { preSelectors, cb } = simpleSelectors[key];
-      expect(preSelectors).toEqual([appSelector]);
-      expect(cb(testState.app)).toEqual(testString);
-    });
-    describe('cardSimpleSelectors', () => {
-      keys = keyStore(cardSimpleSelectors);
-      test.each([
-        keys.certificate,
-        keys.course,
-        keys.courseProvider,
-        keys.courseRun,
-        keys.credit,
-        keys.enrollment,
-        keys.entitlement,
-        keys.gradeData,
-      ])('%s card simple selector forwards corresponding data from passed object', (key) => {
-        testState = { [key]: testString };
-        expect(cardSimpleSelectors[key](testState)).toEqual(testString);
-      });
-      test('relatedPrograms simple selector forwards relatedPrograms from programs obj', () => {
-        expect(
-          cardSimpleSelectors.relatedPrograms({ programs: { relatedPrograms: testString } }),
-        ).toEqual(testString);
-      });
-    });
-    describe('mkCardSelector util', () => {
-      it('takes [card simpleSelector, selector] and creates card selector from cardData', () => {
-        const selector = (data) => ({ selector: data });
-        const simpleSelector = (data) => ({ simpleSelector: data });
-        testData = { some: 'test data' };
-        const oldCourseData = simpleSelectors.courseData;
-        simpleSelectors.courseData = jest.fn().mockReturnValueOnce({ [testCardId]: testData });
-        expect(mkCardSelector(simpleSelector, selector)(testState, testCardId)).toEqual(
-          selector(simpleSelector(testData)),
-        );
-        expect(simpleSelectors.courseData).toHaveBeenCalledWith(testState);
-        simpleSelectors.courseData = oldCourseData;
-      });
-    });
-  });
-});
diff --git a/src/data/redux/hooks/app.js b/src/data/redux/hooks/app.js
deleted file mode 100644
index ec7a75166..000000000
--- a/src/data/redux/hooks/app.js
+++ /dev/null
@@ -1,107 +0,0 @@
-/* eslint-disable react-hooks/rules-of-hooks */
-import { useSelector, useDispatch } from 'react-redux';
-
-import * as redux from 'data/redux';
-import * as module from './app';
-
-const selectors = redux.selectors.app;
-const actions = redux.actions.app;
-
-/** Simple Selectors **/
-export const usePageNumber = () => useSelector(selectors.pageNumber);
-export const useFilters = () => useSelector(selectors.filters);
-export const useEmailConfirmationData = () => useSelector(selectors.emailConfirmation);
-export const useEnterpriseDashboardData = () => useSelector(selectors.enterpriseDashboard);
-export const usePlatformSettingsData = () => useSelector(selectors.platformSettings);
-export const useSelectSessionModalData = () => useSelector(selectors.selectSessionModal);
-export const useSocialShareSettings = () => useSelector(selectors.socialShareSettings);
-
-/** global-level meta-selectors **/
-export const useHasCourses = () => useSelector(selectors.hasCourses);
-export const useCurrentCourseList = (opts) => useSelector(
-  state => selectors.currentList(state, opts),
-);
-export const useShowSelectSessionModal = () => useSelector(selectors.showSelectSessionModal);
-
-// eslint-disable-next-line
-export const useCourseCardData = (selector) => (cardId) => useSelector(
-  (state) => selector(state, cardId),
-);
-/** Course Card selectors **/
-const { courseCard } = selectors;
-export const useCardCertificateData = useCourseCardData(courseCard.certificate);
-export const useCardCourseData = useCourseCardData(courseCard.course);
-export const useCardCourseRunData = useCourseCardData(courseCard.courseRun);
-export const useCardCreditData = useCourseCardData(courseCard.credit);
-export const useCardEnrollmentData = useCourseCardData(courseCard.enrollment);
-export const useCardEntitlementData = useCourseCardData(courseCard.entitlement);
-export const useCardGradeData = useCourseCardData(courseCard.gradeData);
-export const useCardProviderData = useCourseCardData(courseCard.courseProvider);
-export const useCardRelatedProgramsData = useCourseCardData(courseCard.relatedPrograms);
-
-export const useCardSocialSettingsData = (cardId) => {
-  const socialShareSettings = module.useSocialShareSettings();
-  const { socialShareUrl } = module.useCardCourseData(cardId);
-  const defaultSettings = { isEnabled: false, shareUrl: '' };
-
-  if (!socialShareSettings) {
-    return { facebook: defaultSettings, twitter: defaultSettings };
-  }
-  const { facebook, twitter } = socialShareSettings;
-  const loadSettings = (target) => ({
-    isEnabled: target.isEnabled,
-    shareUrl: `${socialShareUrl}?${target.utmParams}`,
-  });
-  return { facebook: loadSettings(facebook), twitter: loadSettings(twitter) };
-};
-
-export const useCardExecEdTrackingParam = (cardId) => {
-  const { isExecEd2UCourse } = module.useCardEnrollmentData(cardId);
-  const { authOrgId } = module.useEnterpriseDashboardData(cardId);
-  return isExecEd2UCourse ? `?org_id=${authOrgId}` : '';
-};
-
-/** Events **/
-export const useUpdateSelectSessionModalCallback = (cardId) => {
-  const dispatch = useDispatch();
-  return () => dispatch(actions.updateSelectSessionModal(cardId));
-};
-
-export const useTrackCourseEvent = (tracker, cardId, ...args) => {
-  const { courseId } = module.useCardCourseRunData(cardId);
-  return (e) => tracker(courseId, ...args)(e);
-};
-
-export const useSetPageNumber = () => {
-  const dispatch = useDispatch();
-  return (value) => dispatch(actions.setPageNumber(value));
-};
-
-export const useSetFilters = () => {
-  const dispatch = useDispatch();
-  return (value) => dispatch(actions.setFilters(value));
-};
-
-export const useAddFilter = () => {
-  const dispatch = useDispatch();
-  return (value) => dispatch(actions.addFilter(value));
-};
-
-export const useRemoveFilter = () => {
-  const dispatch = useDispatch();
-  return (value) => dispatch(actions.removeFilter(value));
-};
-
-export const useClearFilters = () => {
-  const dispatch = useDispatch();
-  return (value) => dispatch(actions.clearFilters(value));
-};
-
-export const useLoadData = () => {
-  const dispatch = useDispatch();
-  return ({ courses, ...globalData }) => {
-    dispatch(actions.setPageNumber(1));
-    dispatch(actions.loadGlobalData(globalData));
-    dispatch(actions.loadCourses({ courses }));
-  };
-};
diff --git a/src/data/redux/hooks/index.js b/src/data/redux/hooks/index.js
deleted file mode 100644
index ba6f57432..000000000
--- a/src/data/redux/hooks/index.js
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from './app';
-export * from './requests';
diff --git a/src/data/redux/hooks/requests.js b/src/data/redux/hooks/requests.js
deleted file mode 100644
index 79537b824..000000000
--- a/src/data/redux/hooks/requests.js
+++ /dev/null
@@ -1,45 +0,0 @@
-import { useSelector, useDispatch } from 'react-redux';
-
-import * as redux from 'data/redux';
-import * as module from './requests';
-
-const selectors = redux.selectors.requests;
-const actions = redux.actions.requests;
-
-export const useMasqueradeData = () => useSelector(selectors.masquerade);
-
-export const statusSelector = selector => (requestName) => useSelector(selector(requestName));
-export const useRequestIsPending = module.statusSelector(selectors.isPending);
-export const useRequestIsFailed = module.statusSelector(selectors.isFailed);
-export const useRequestIsCompleted = module.statusSelector(selectors.isCompleted);
-export const useRequestIsInactive = module.statusSelector(selectors.isInactive);
-export const useRequestError = module.statusSelector(selectors.error);
-export const useRequestErrorCode = module.statusSelector(selectors.errorCode);
-export const useRequestErrorStatus = module.statusSelector(selectors.errorStatus);
-export const useRequestData = module.statusSelector(selectors.data);
-
-export const useMakeNetworkRequest = () => {
-  const dispatch = useDispatch();
-  return ({
-    requestKey,
-    promise,
-    onSuccess,
-    onFailure,
-  }) => {
-    dispatch(actions.startRequest({ requestKey }));
-    return promise.then((response) => {
-      if (onSuccess) { onSuccess(response); }
-      dispatch(actions.completeRequest({ requestKey, response }));
-    }).catch((error) => {
-      if (onFailure) { onFailure(error); }
-      dispatch(actions.failRequest({ requestKey, error }));
-    });
-  };
-};
-
-export const useClearRequest = () => {
-  const dispatch = useDispatch();
-  return (requestKey) => {
-    dispatch(actions.clearRequest({ requestKey }));
-  };
-};
diff --git a/src/data/redux/index.js b/src/data/redux/index.js
deleted file mode 100644
index 24e6e10b3..000000000
--- a/src/data/redux/index.js
+++ /dev/null
@@ -1,37 +0,0 @@
-import { combineReducers } from 'redux';
-
-import { StrictDict } from 'utils';
-
-import * as app from './app';
-import * as requests from './requests';
-
-const modules = {
-  app,
-  requests,
-};
-
-/**
- * Extracts keys from the modules object and the provided propName parameter to locate the
- * corresponding object for that propName.
- * Example: moduleProps('reducer') will return an aggregated object containing the reducer for each module
- *
- * @param {string} propName Used to locate the prop in each module
- * @returns {object} Aggregated values for the provided propName
- */
-const moduleProps = (propName) => Object.keys(modules).reduce(
-  (obj, moduleKey) => {
-    const value = modules[moduleKey][propName];
-    return value ? { ...obj, [moduleKey]: value } : obj;
-  },
-  {},
-);
-
-const rootReducer = combineReducers(moduleProps('reducer'));
-
-const actions = StrictDict(moduleProps('actions'));
-
-const selectors = StrictDict(moduleProps('selectors'));
-
-export { actions, selectors };
-
-export default rootReducer;
diff --git a/src/data/redux/requests/index.js b/src/data/redux/requests/index.js
deleted file mode 100644
index 8abd5f91d..000000000
--- a/src/data/redux/requests/index.js
+++ /dev/null
@@ -1,2 +0,0 @@
-export { actions, reducer } from './reducer';
-export { default as selectors } from './selectors';
diff --git a/src/data/redux/requests/reducer.js b/src/data/redux/requests/reducer.js
deleted file mode 100644
index e29bbf1ae..000000000
--- a/src/data/redux/requests/reducer.js
+++ /dev/null
@@ -1,54 +0,0 @@
-import { createSlice } from '@reduxjs/toolkit';
-
-import { StrictDict } from 'utils';
-
-import { RequestStates, RequestKeys } from 'data/constants/requests';
-
-const initialState = {
-  [RequestKeys.initialize]: { status: RequestStates.inactive },
-  [RequestKeys.refreshList]: { status: RequestStates.inactive },
-  [RequestKeys.enrollEntitlementSession]: { status: RequestStates.inactive },
-  [RequestKeys.leaveEntitlementSession]: { status: RequestStates.inactive },
-  [RequestKeys.masquerade]: { status: RequestStates.inactive },
-};
-
-// eslint-disable-next-line no-unused-vars
-const requests = createSlice({
-  name: 'requests',
-  initialState,
-  reducers: {
-    startRequest: (state, { payload }) => ({
-      ...state,
-      [payload.requestKey]: {
-        status: RequestStates.pending,
-      },
-    }),
-    completeRequest: (state, { payload }) => ({
-      ...state,
-      [payload.requestKey]: {
-        status: RequestStates.completed,
-        response: payload.response,
-      },
-    }),
-    failRequest: (state, { payload }) => ({
-      ...state,
-      [payload.requestKey]: {
-        status: RequestStates.failed,
-        error: payload.error,
-      },
-    }),
-    clearRequest: (state, { payload }) => ({
-      ...state,
-      [payload.requestKey]: {},
-    }),
-  },
-});
-
-const actions = StrictDict(requests.actions);
-const { reducer } = requests;
-
-export {
-  actions,
-  reducer,
-  initialState,
-};
diff --git a/src/data/redux/requests/reducer.test.js b/src/data/redux/requests/reducer.test.js
deleted file mode 100644
index 8eb39ea65..000000000
--- a/src/data/redux/requests/reducer.test.js
+++ /dev/null
@@ -1,62 +0,0 @@
-import { RequestStates } from 'data/constants/requests';
-import { initialState, actions, reducer } from './reducer';
-
-const testingState = {
-  ...initialState,
-  arbitraryField: 'arbitrary',
-};
-
-describe('requests reducer', () => {
-  it('has initial state', () => {
-    expect(reducer(undefined, {})).toEqual(initialState);
-  });
-
-  const testValue = 'roll for initiative';
-  const testKey = 'test-key';
-  describe('handling actions', () => {
-    describe('startRequest', () => {
-      it('adds a pending status for the given key', () => {
-        expect(reducer(
-          testingState,
-          actions.startRequest({ requestKey: testKey }),
-        )).toEqual({
-          ...testingState,
-          [testKey]: { status: RequestStates.pending },
-        });
-      });
-    });
-    describe('completeRequest', () => {
-      it('adds a completed status with passed response', () => {
-        expect(reducer(
-          testingState,
-          actions.completeRequest({ requestKey: testKey, response: testValue }),
-        )).toEqual({
-          ...testingState,
-          [testKey]: { status: RequestStates.completed, response: testValue },
-        });
-      });
-    });
-    describe('failRequest', () => {
-      it('adds a failed status with passed error', () => {
-        expect(reducer(
-          testingState,
-          actions.failRequest({ requestKey: testKey, error: testValue }),
-        )).toEqual({
-          ...testingState,
-          [testKey]: { status: RequestStates.failed, error: testValue },
-        });
-      });
-    });
-    describe('clearRequest', () => {
-      it('cleanup status and error', () => {
-        expect(reducer(
-          testingState,
-          actions.clearRequest({ requestKey: testKey, error: testValue }),
-        )).toEqual({
-          ...testingState,
-          [testKey]: {},
-        });
-      });
-    });
-  });
-});
diff --git a/src/data/redux/requests/selectors.js b/src/data/redux/requests/selectors.js
deleted file mode 100644
index ae2bd143b..000000000
--- a/src/data/redux/requests/selectors.js
+++ /dev/null
@@ -1,40 +0,0 @@
-import { StrictDict } from 'utils';
-import { RequestStates, RequestKeys } from 'data/constants/requests';
-// import * as module from './selectors';
-
-export const requestStatus = (state, { requestKey }) => state.requests[requestKey];
-
-const statusSelector = (fn) => (requestKey) => (state) => fn(state.requests[requestKey]);
-
-export const isInactive = ({ status }) => status === RequestStates.inactive;
-export const isPending = ({ status }) => status === RequestStates.pending;
-export const isCompleted = ({ status }) => status === RequestStates.completed;
-export const isFailed = ({ status }) => status === RequestStates.failed;
-export const error = (request) => request.error;
-export const errorStatus = (request) => request.error?.response?.status;
-export const errorCode = (request) => request.error?.response?.data;
-
-export const data = (request) => request.data;
-
-export const masquerade = (state) => {
-  const request = requestStatus(state, { requestKey: RequestKeys.masquerade });
-  return {
-    isMasquerading: isCompleted(request),
-    isMasqueradingFailed: isFailed(request),
-    isMasqueradingPending: isPending(request),
-    masqueradeErrorStatus: errorStatus(request),
-  };
-};
-
-export default StrictDict({
-  requestStatus,
-  isInactive: statusSelector(isInactive),
-  isPending: statusSelector(isPending),
-  isCompleted: statusSelector(isCompleted),
-  isFailed: statusSelector(isFailed),
-  error: statusSelector(error),
-  errorCode: statusSelector(errorCode),
-  errorStatus: statusSelector(errorStatus),
-  data: statusSelector(data),
-  masquerade,
-});
diff --git a/src/data/redux/requests/selectors.test.js b/src/data/redux/requests/selectors.test.js
deleted file mode 100644
index f80936411..000000000
--- a/src/data/redux/requests/selectors.test.js
+++ /dev/null
@@ -1,110 +0,0 @@
-import { RequestStates, RequestKeys } from 'data/constants/requests';
-
-import selectors from './selectors';
-
-const requestKey = 'my-test-request-key';
-const requestData = { some: 'request-data' };
-const inactiveRequest = { status: RequestStates.inactive, some: 'request-data' };
-const pendingRequest = { status: RequestStates.pending, some: 'request-data' };
-const completedRequest = { status: RequestStates.completed, some: 'request-data' };
-const failedRequest = { status: RequestStates.failed, some: 'request-data' };
-
-const testValue = 'my-test-value';
-
-const testErrorValue = {
-  response: {
-    status: 500,
-    data: 'my-test-error',
-  },
-};
-
-const testState = {
-  requests: {
-    [requestKey]: requestData,
-  },
-};
-const mockUseSelector = (selector, state) => selector(state);
-const genRequests = (request) => ({
-  requests: { [requestKey]: request },
-});
-const select = (selector, request) => (
-  mockUseSelector(selector(requestKey), genRequests(request))
-);
-describe('requests selectors unit tests', () => {
-  test('requestStatus returns data associated with given key', () => {
-    expect(selectors.requestStatus(testState, { requestKey })).toEqual(requestData);
-  });
-  const testStatusSelector = (selector, matchingRequest) => {
-    expect(mockUseSelector(selector(requestKey), testState)).toEqual(false);
-    expect(mockUseSelector(
-      selector(requestKey),
-      { requests: { [requestKey]: matchingRequest } },
-    )).toEqual(true);
-  };
-  test('isInactive returns true iff the given request is inactive', () => {
-    testStatusSelector(selectors.isInactive, inactiveRequest);
-  });
-  test('isPending returns true iff the given request is pending', () => {
-    testStatusSelector(selectors.isPending, pendingRequest);
-  });
-  test('isCompleted returns true iff the given request is completed', () => {
-    testStatusSelector(selectors.isCompleted, completedRequest);
-  });
-  test('isFailed returns true iff the given request is failed', () => {
-    testStatusSelector(selectors.isFailed, failedRequest);
-  });
-  test('error returns the error from the request', () => {
-    expect(select(selectors.error, { error: testValue })).toEqual(testValue);
-  });
-  test('errorStatus returns the error response status', () => {
-    expect(select(selectors.errorStatus, {})).toEqual(undefined);
-    expect(select(selectors.errorStatus, { error: {} })).toEqual(undefined);
-    expect(select(selectors.errorStatus, { error: { response: {} } })).toEqual(undefined);
-    expect(select(selectors.errorStatus, { error: { response: { status: testValue } } }))
-      .toEqual(testValue);
-    expect(select(selectors.errorStatus, { error: testErrorValue })).toEqual(
-      testErrorValue.response.status,
-    );
-  });
-  test('errorCode returns the error response data', () => {
-    expect(select(selectors.errorCode, {})).toEqual(undefined);
-    expect(select(selectors.errorCode, { error: {} })).toEqual(undefined);
-    expect(select(selectors.errorCode, { error: { response: {} } })).toEqual(undefined);
-    expect(select(selectors.errorCode, { error: { response: { data: testValue } } }))
-      .toEqual(testValue);
-    expect(select(selectors.errorCode, { error: testErrorValue })).toEqual(
-      testErrorValue.response.data,
-    );
-  });
-  test('data reurns the request data', () => {
-    expect(select(selectors.data, { data: testValue })).toEqual(testValue);
-  });
-  test('masquerade returns the masquerade data', () => {
-    const mockResponse = (response) => ({
-      requests: {
-        [RequestKeys.masquerade]: response,
-      },
-    });
-    expect(selectors.masquerade(mockResponse(completedRequest))).toEqual({
-      isMasquerading: true,
-      isMasqueradingFailed: false,
-      isMasqueradingPending: false,
-      masqueradeErrorStatus: undefined,
-    });
-    expect(selectors.masquerade(mockResponse(pendingRequest))).toEqual({
-      isMasquerading: false,
-      isMasqueradingFailed: false,
-      isMasqueradingPending: true,
-      masqueradeErrorStatus: undefined,
-    });
-    expect(selectors.masquerade(mockResponse({
-      ...failedRequest,
-      error: testErrorValue,
-    }))).toEqual({
-      isMasquerading: false,
-      isMasqueradingFailed: true,
-      isMasqueradingPending: false,
-      masqueradeErrorStatus: testErrorValue.response.status,
-    });
-  });
-});
diff --git a/src/data/services/lms/api.js b/src/data/services/lms/api.js
deleted file mode 100644
index e2d477181..000000000
--- a/src/data/services/lms/api.js
+++ /dev/null
@@ -1,77 +0,0 @@
-import eventNames from 'tracking/constants';
-import {
-  client,
-  get,
-  post,
-  stringifyUrl,
-} from './utils';
-import {
-  apiKeys,
-  unenrollmentAction,
-  enableEmailsAction,
-} from './constants';
-import urls from './urls';
-import * as module from './api';
-
-/*********************************************************************************
- * GET Actions
- *********************************************************************************/
-export const initializeList = ({ user } = {}) => get(
-  stringifyUrl(urls.getInitApiUrl(), { [apiKeys.user]: user }),
-);
-
-export const updateEntitlementEnrollment = ({ uuid, courseId }) => post(
-  urls.entitlementEnrollment(uuid),
-  { [apiKeys.courseRunId]: courseId },
-);
-
-export const deleteEntitlementEnrollment = ({ uuid, isRefundable }) => client()
-  .delete(
-    stringifyUrl(
-      urls.entitlementEnrollment(uuid),
-      { [apiKeys.isRefund]: isRefundable },
-    ),
-  );
-
-export const updateEmailSettings = ({ courseId, enable }) => post(
-  urls.updateEmailSettings(),
-  { [apiKeys.courseId]: courseId, ...(enable && enableEmailsAction) },
-);
-
-export const unenrollFromCourse = ({ courseId }) => post(
-  urls.courseUnenroll(),
-  { [apiKeys.courseId]: courseId, ...unenrollmentAction },
-);
-
-export const logEvent = ({ eventName, data, courseId }) => post(urls.event(), {
-  courserun_key: courseId,
-  event_type: eventName,
-  page: window.location.href,
-  event: JSON.stringify(data),
-});
-
-export const logShare = ({ courseId, site }) => module.logEvent({
-  eventName: eventNames.shareClicked,
-  courseId,
-  data: {
-    course_id: courseId,
-    social_media_site: site,
-    location: 'dashboard',
-  },
-});
-
-export const createCreditRequest = ({ providerId, courseId, username }) => post(
-  urls.creditRequestUrl(providerId),
-  { course_key: courseId, username },
-);
-
-export default {
-  initializeList,
-  unenrollFromCourse,
-  updateEmailSettings,
-  updateEntitlementEnrollment,
-  deleteEntitlementEnrollment,
-  logEvent,
-  logShare,
-  createCreditRequest,
-};
diff --git a/src/data/services/lms/api.test.js b/src/data/services/lms/api.test.js
deleted file mode 100644
index af24aad9f..000000000
--- a/src/data/services/lms/api.test.js
+++ /dev/null
@@ -1,156 +0,0 @@
-import { mockLocation } from 'testUtils';
-import { keyStore } from 'utils';
-import eventNames from 'tracking/constants';
-import * as api from './api';
-import * as utils from './utils';
-import urls from './urls';
-import {
-  apiKeys,
-  unenrollmentAction,
-  enableEmailsAction,
-} from './constants';
-
-jest.mock('./utils', () => {
-  const deleteFn = (...args) => ({ delete: args });
-  return {
-    client: () => ({ delete: deleteFn }),
-    delete: deleteFn,
-    get: (...args) => ({ get: args }),
-    post: jest.fn((...args) => ({ post: args })),
-    stringifyUrl: (...args) => ({ stringifyUrl: args }),
-  };
-});
-
-const testUser = 'test-user';
-const testUuid = 'test-UUID';
-const courseId = 'TEST-course-ID';
-const isRefundable = 'test-is-refundable';
-
-const moduleKeys = keyStore(api);
-
-describe('lms api methods', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-  test('keys identical to module', () => {
-    /* eslint-disable-next-line global-require */
-    const { default: defaultApi, ...rest } = require('./api');
-    expect(Object.keys(rest).sort()).toMatchObject(Object.keys(defaultApi).sort());
-  });
-  describe('initializeList', () => {
-    test('calls get with the correct url and user', () => {
-      const userArg = {
-        [apiKeys.user]: testUser,
-      };
-      expect(api.initializeList(userArg)).toEqual(
-        utils.get(utils.stringifyUrl(urls.getInitApiUrl(), userArg)),
-      );
-    });
-  });
-  describe('updateEntitlementEnrollment', () => {
-    it('calls post on entitlementEnrollment url with uuid and course run ID', () => {
-      expect(
-        api.updateEntitlementEnrollment({ uuid: testUuid, courseId }),
-      ).toEqual(
-        utils.post(
-          urls.entitlementEnrollment(testUuid),
-          { [apiKeys.courseRunId]: courseId },
-        ),
-      );
-    });
-  });
-  describe('deleteEntitlementEnrollment', () => {
-    it('calls delete on entitlementEnrollment url with uuid and null course run ID', () => {
-      expect(
-        api.deleteEntitlementEnrollment({ uuid: testUuid, isRefundable }),
-      ).toEqual(
-        utils.client().delete(utils.stringifyUrl(
-          urls.entitlementEnrollment(testUuid),
-          { [apiKeys.isRefund]: isRefundable },
-        )),
-      );
-    });
-  });
-  describe('updateEmailSettings', () => {
-    describe('disable', () => {
-      it('calls post on updateEmailSettings url with course ID', () => {
-        expect(
-          api.updateEmailSettings({ courseId, enable: false }),
-        ).toEqual(
-          utils.post(urls.updateEmailSettings(), { [apiKeys.courseId]: courseId }),
-        );
-      });
-    });
-    describe('enable', () => {
-      it('calls post on updateEmailSettings url with course ID and enableEmailsAction', () => {
-        expect(
-          api.updateEmailSettings({ courseId, enable: true }),
-        ).toEqual(
-          utils.post(
-            urls.updateEmailSettings(),
-            { [apiKeys.courseId]: courseId, ...enableEmailsAction },
-          ),
-        );
-      });
-    });
-  });
-  describe('unenrollFromCourse', () => {
-    it('calls post on unenrollFromCourse url with courseId and unenrollment action', () => {
-      expect(
-        api.unenrollFromCourse({ courseId }),
-      ).toEqual(
-        utils.post(
-          urls.courseUnenroll(),
-          { [apiKeys.courseId]: courseId, ...unenrollmentAction },
-        ),
-      );
-    });
-  });
-  describe('logging events', () => {
-    describe('logEvent', () => {
-      it('posts to event url with event data', () => {
-        const href = 'test-href';
-        const eventName = 'test-event-key';
-        const data = { some: 'data' };
-        mockLocation(href);
-        expect(
-          api.logEvent({ courseId, eventName, data }),
-        ).toEqual(
-          utils.post(urls.event(), {
-            courserun_key: courseId,
-            event_type: eventName,
-            page: href,
-            event: JSON.stringify(data),
-          }),
-        );
-      });
-    });
-    describe('logged events', () => {
-      const logEvent = (args) => ({ logEvent: args });
-      beforeEach(() => {
-        jest.spyOn(api, moduleKeys.logEvent).mockImplementation(logEvent);
-      });
-      test('logShare sends share clicke vent with course id, side and location', () => {
-        const site = 'test-site';
-        expect(api.logShare({ courseId, site })).toEqual(logEvent({
-          eventName: eventNames.shareClicked,
-          courseId,
-          data: { course_id: courseId, social_media_site: site, location: 'dashboard' },
-        }));
-      });
-    });
-  });
-  describe('credit requests', () => {
-    describe('createCreditRequest', () => {
-      const providerId = 'test-provider-id';
-      const username = 'test-username';
-      it('posts course ID and username to credit request url', () => {
-        api.createCreditRequest({ providerId, courseId, username });
-        expect(utils.post).toHaveBeenCalledWith(
-          urls.creditRequestUrl(providerId),
-          { course_key: courseId, username },
-        );
-      });
-    });
-  });
-});
diff --git a/src/data/services/lms/api.test.tsx b/src/data/services/lms/api.test.tsx
new file mode 100644
index 000000000..fcfedbd61
--- /dev/null
+++ b/src/data/services/lms/api.test.tsx
@@ -0,0 +1,288 @@
+import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { apiKeys, enableEmailsAction, unenrollmentAction } from 'data/services/lms/constants';
+import urls from 'data/services/lms/urls';
+import { stringifyUrl } from 'data/services/lms/utils';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import eventNames from 'tracking/constants';
+import {
+  initializeList,
+  unenrollFromCourse,
+  updateEntitlementEnrollment,
+  deleteEntitlementEnrollment,
+  updateEmailSettings,
+  logEvent,
+  logShare,
+  createCreditRequest,
+  sendConfirmEmail,
+} from './api';
+
+// Mock dependencies
+jest.mock('@edx/frontend-platform/auth');
+jest.mock('data/services/lms/constants');
+jest.mock('data/services/lms/urls');
+jest.mock('data/services/lms/utils');
+jest.mock('tracking/constants');
+
+const mockHttpClient = {
+  get: jest.fn(),
+  post: jest.fn(),
+  delete: jest.fn(),
+};
+
+const mockedGetAuthenticatedHttpClient = getAuthenticatedHttpClient as jest.MockedFunction<
+  typeof getAuthenticatedHttpClient>;
+const mockedStringifyUrl = stringifyUrl as jest.MockedFunction<typeof stringifyUrl>;
+
+describe('API functions', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockedGetAuthenticatedHttpClient.mockReturnValue(mockHttpClient as any);
+
+    // Mock constants
+    (apiKeys as any) = {
+      user: 'user',
+      courseId: 'course_id',
+      courseRunId: 'course_run_id',
+      isRefund: 'is_refund',
+    };
+
+    (enableEmailsAction as any) = { enable: true };
+    (unenrollmentAction as any) = { action: 'unenroll' };
+    (eventNames as any) = { shareClicked: 'share_clicked' };
+
+    // Mock urls
+    (urls as any) = {
+      getInitApiUrl: jest.fn(() => '/api/init'),
+      courseUnenroll: jest.fn(() => '/api/unenroll'),
+      entitlementEnrollment: jest.fn((uuid) => `/api/entitlement/${uuid}`),
+      updateEmailSettings: jest.fn(() => '/api/email-settings'),
+      event: jest.fn(() => '/api/event'),
+      creditRequestUrl: jest.fn((providerId) => `/api/credit/${providerId}`),
+    };
+
+    mockedStringifyUrl.mockImplementation((url, params) => {
+      const paramString = Object.entries(params || {}).map(([key, value]) => `${key}=${value}`).join('&');
+      return paramString ? `${url}?${paramString}` : url;
+    });
+
+    // Mock window.location
+    delete (window as any).location;
+    (window as any).location = { href: 'https://example.com/dashboard' };
+  });
+
+  describe('initializeList', () => {
+    it('should make GET request to init API with user parameter', async () => {
+      const mockData = { courses: [], entitlements: [] };
+      mockHttpClient.get.mockResolvedValue({ data: mockData });
+
+      const result = await initializeList('test-user');
+
+      expect(urls.getInitApiUrl).toHaveBeenCalled();
+      expect(stringifyUrl).toHaveBeenCalledWith('/api/init', { user: 'test-user' });
+      expect(mockHttpClient.get).toHaveBeenCalledWith('/api/init?user=test-user');
+      expect(result).toEqual(mockData);
+    });
+
+    it('should handle null user parameter', async () => {
+      const mockData = { courses: [] };
+      mockHttpClient.get.mockResolvedValue({ data: mockData });
+
+      await initializeList(null);
+
+      expect(stringifyUrl).toHaveBeenCalledWith('/api/init', { user: null });
+    });
+  });
+
+  describe('unenrollFromCourse', () => {
+    it('should make POST request to unenroll from course with FormData', async () => {
+      const mockResponse = { status: 200 };
+      mockHttpClient.post.mockResolvedValue(mockResponse);
+      const result = await unenrollFromCourse({ courseId: 'course-123' });
+      expect(urls.courseUnenroll).toHaveBeenCalled();
+      expect(mockHttpClient.post).toHaveBeenCalledWith('/api/unenroll', expect.any(FormData));
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('updateEntitlementEnrollment', () => {
+    it('should make POST request to update entitlement enrollment', async () => {
+      const mockResponse = { status: 200 };
+      mockHttpClient.post.mockResolvedValue(mockResponse);
+
+      const result = await updateEntitlementEnrollment({
+        uuid: 'entitlement-uuid',
+        courseId: 'course-123',
+      });
+
+      expect(urls.entitlementEnrollment).toHaveBeenCalledWith('entitlement-uuid');
+      expect(mockHttpClient.post).toHaveBeenCalledWith('/api/entitlement/entitlement-uuid', {
+        course_run_id: 'course-123',
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('deleteEntitlementEnrollment', () => {
+    it('should make DELETE request with refundable flag', async () => {
+      const mockResponse = { status: 204 };
+      mockHttpClient.delete.mockResolvedValue(mockResponse);
+
+      const result = await deleteEntitlementEnrollment({
+        uuid: 'entitlement-uuid',
+        isRefundable: true,
+      });
+
+      expect(urls.entitlementEnrollment).toHaveBeenCalledWith('entitlement-uuid');
+      expect(stringifyUrl).toHaveBeenCalledWith('/api/entitlement/entitlement-uuid', {
+        is_refund: true,
+      });
+      expect(mockHttpClient.delete).toHaveBeenCalledWith('/api/entitlement/entitlement-uuid?is_refund=true');
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should handle non-refundable deletion', async () => {
+      const mockResponse = { status: 204 };
+      mockHttpClient.delete.mockResolvedValue(mockResponse);
+
+      await deleteEntitlementEnrollment({
+        uuid: 'entitlement-uuid',
+        isRefundable: false,
+      });
+
+      expect(stringifyUrl).toHaveBeenCalledWith('/api/entitlement/entitlement-uuid', {
+        is_refund: false,
+      });
+    });
+  });
+
+  describe('updateEmailSettings', () => {
+    it('should make POST request to enable email settings', async () => {
+      const mockResponse = { status: 200 };
+      mockHttpClient.post.mockResolvedValue(mockResponse);
+
+      const result = await updateEmailSettings({
+        courseId: 'course-123',
+        enable: true,
+      });
+
+      expect(urls.updateEmailSettings).toHaveBeenCalled();
+      expect(mockHttpClient.post).toHaveBeenCalledWith('/api/email-settings', {
+        course_id: 'course-123',
+        enable: true,
+      });
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should make POST request to disable email settings', async () => {
+      const mockResponse = { status: 200 };
+      mockHttpClient.post.mockResolvedValue(mockResponse);
+
+      const result = await updateEmailSettings({
+        courseId: 'course-123',
+        enable: false,
+      });
+
+      expect(mockHttpClient.post).toHaveBeenCalledWith('/api/email-settings', {
+        course_id: 'course-123',
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('logEvent', () => {
+    it('should make POST request to log event', async () => {
+      const mockResponse = { status: 200 };
+      mockHttpClient.post.mockResolvedValue(mockResponse);
+
+      const eventData = {
+        eventName: 'test-event',
+        data: { key: 'value' },
+        courseId: 'course-123',
+      };
+
+      const result = await logEvent(eventData);
+
+      expect(urls.event).toHaveBeenCalled();
+      expect(mockHttpClient.post).toHaveBeenCalledWith('/api/event', {
+        courserun_key: 'course-123',
+        event_type: 'test-event',
+        page: 'https://example.com/dashboard',
+        event: JSON.stringify({ key: 'value' }),
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('logShare', () => {
+    it('should call logEvent with share event data', async () => {
+      const mockResponse = { status: 200 };
+      mockHttpClient.post.mockResolvedValue(mockResponse);
+
+      const result = await logShare({
+        courseId: 'course-123',
+        site: 'facebook',
+      });
+
+      expect(mockHttpClient.post).toHaveBeenCalledWith('/api/event', {
+        courserun_key: 'course-123',
+        event_type: 'share_clicked',
+        page: 'https://example.com/dashboard',
+        event: JSON.stringify({
+          course_id: 'course-123',
+          social_media_site: 'facebook',
+          location: 'dashboard',
+        }),
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('createCreditRequest', () => {
+    it('should make POST request to create credit request', async () => {
+      const mockResponse = { status: 201 };
+      mockHttpClient.post.mockResolvedValue(mockResponse);
+
+      const result = await createCreditRequest({
+        providerId: 'provider-123',
+        courseId: 'course-123',
+        username: 'test-user',
+      });
+
+      expect(urls.creditRequestUrl).toHaveBeenCalledWith('provider-123');
+      expect(mockHttpClient.post).toHaveBeenCalledWith('/api/credit/provider-123', {
+        course_key: 'course-123',
+        username: 'test-user',
+      });
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('sendConfirmEmail', () => {
+    it('should make POST request to send confirmation email', async () => {
+      const mockResponse = { status: 200 };
+      mockHttpClient.post.mockResolvedValue(mockResponse);
+
+      const result = await sendConfirmEmail('https://example.com/send-email');
+
+      expect(mockHttpClient.post).toHaveBeenCalledWith('https://example.com/send-email');
+      expect(result).toEqual(mockResponse);
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should propagate network errors', async () => {
+      const networkError = new Error('Network error');
+      mockHttpClient.get.mockRejectedValue(networkError);
+
+      await expect(initializeList('test-user')).rejects.toThrow('Network error');
+    });
+
+    it('should propagate API errors', async () => {
+      const apiError = { response: { status: 404, data: { error: 'Not found' } } };
+      mockHttpClient.post.mockRejectedValue(apiError);
+
+      await expect(unenrollFromCourse({ courseId: 'invalid-course' })).rejects.toEqual(apiError);
+    });
+  });
+});
diff --git a/src/data/services/lms/api.ts b/src/data/services/lms/api.ts
new file mode 100644
index 000000000..6ed5e0065
--- /dev/null
+++ b/src/data/services/lms/api.ts
@@ -0,0 +1,95 @@
+import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
+import { apiKeys, enableEmailsAction, unenrollmentAction } from 'data/services/lms/constants';
+import urls from 'data/services/lms/urls';
+import { stringifyUrl } from 'data/services/lms/utils';
+import eventNames from 'tracking/constants';
+
+const initializeList = async (user) => {
+  const { data } = await getAuthenticatedHttpClient().get(
+    stringifyUrl(urls.getInitApiUrl(), { [apiKeys.user]: user }),
+  );
+  return data;
+};
+
+const unenrollFromCourse = async ({ courseId }) => {
+  const url = urls.courseUnenroll();
+  const formData = new FormData();
+  formData.append(apiKeys.courseId, courseId);
+  Object.entries(unenrollmentAction).forEach(([key, value]) => {
+    formData.append(key, value);
+  });
+  const response = await getAuthenticatedHttpClient().post(url, formData);
+  return response;
+};
+
+const updateEntitlementEnrollment = async ({ uuid, courseId }) => {
+  const url = urls.entitlementEnrollment(uuid);
+  const content = { [apiKeys.courseRunId]: courseId };
+  const response = await getAuthenticatedHttpClient().post(url, content);
+  return response;
+};
+
+const deleteEntitlementEnrollment = async ({ uuid, isRefundable }) => {
+  const url = stringifyUrl(
+    urls.entitlementEnrollment(uuid),
+    { [apiKeys.isRefund]: isRefundable },
+  );
+  const response = await getAuthenticatedHttpClient().delete(url);
+  return response;
+};
+
+const updateEmailSettings = async ({ courseId, enable }) => {
+  const url = urls.updateEmailSettings();
+  const content = { [apiKeys.courseId]: courseId, ...(enable && enableEmailsAction) };
+  const response = await getAuthenticatedHttpClient().post(url, content);
+  return response;
+};
+
+const logEvent = async ({ eventName, data, courseId }) => {
+  const url = urls.event();
+  const content = {
+    courserun_key: courseId,
+    event_type: eventName,
+    page: window.location.href,
+    event: JSON.stringify(data),
+  };
+  const response = await getAuthenticatedHttpClient().post(url, content);
+  return response;
+};
+
+const logShare = ({ courseId, site }) => {
+  const eventData = {
+    eventName: eventNames.shareClicked,
+    courseId,
+    data: {
+      course_id: courseId,
+      social_media_site: site,
+      location: 'dashboard',
+    },
+  };
+  return logEvent(eventData);
+};
+
+const createCreditRequest = async ({ providerId, courseId, username }) => {
+  const url = urls.creditRequestUrl(providerId);
+  const content = { course_key: courseId, username };
+  const response = await getAuthenticatedHttpClient().post(url, content);
+  return response;
+};
+
+const sendConfirmEmail = async (sendEmailUrl: string) => {
+  const response = await getAuthenticatedHttpClient().post(sendEmailUrl);
+  return response;
+};
+
+export {
+  initializeList,
+  unenrollFromCourse,
+  updateEntitlementEnrollment,
+  deleteEntitlementEnrollment,
+  updateEmailSettings,
+  logEvent,
+  logShare,
+  createCreditRequest,
+  sendConfirmEmail,
+};
diff --git a/src/data/services/lms/fakeData/courses.js b/src/data/services/lms/fakeData/courses.js
deleted file mode 100644
index 31911a969..000000000
--- a/src/data/services/lms/fakeData/courses.js
+++ /dev/null
@@ -1,828 +0,0 @@
-import { StrictDict } from 'utils';
-import creditVals from 'data/constants/credit';
-
-export const providers = StrictDict({
-  edx: { name: 'edX Course Provider' },
-  mit: { name: 'MIT' },
-});
-
-export const relatedPrograms = [
-  {
-    provider: 'HarvardX',
-    bannerImgSrc: 'https://prod-discovery.edx-cdn.org/media/course/image/327c8e4f-315a-417b-9857-046dfc90c243-677b97464958.small.jpg',
-    logoImgSrc: 'https://prod-discovery.edx-cdn.org/organization/certificate_logos/44022f13-20df-4666-9111-cede3e5dc5b6-770e00385e7e.png',
-    title: 'Relativity in Modern Mechanics',
-    programUrl: 'www.edx/my-program',
-    programType: 'MicroBachelors Program',
-    numberOfCourses: 3,
-  },
-  {
-    provider: 'University  of Maryland',
-    bannerImgSrc: 'https://prod-discovery.edx-cdn.org/media/programs/banner_images/9a310b98-8f27-439e-be85-12d6460245c9-f2efca129273.small.jpg',
-    logoImgSrc: 'https://prod-discovery.edx-cdn.org/organization/certificate_logos/b9dc96da-b3fc-45a6-b6b7-b8e12eb79335-ac60112330e3.png',
-    title: 'Pandering for Modern Professionals',
-    programUrl: 'www.edx/my-program-2',
-    programType: 'MicroBachelors Program',
-    programTypeUrl: 'www.edx/my-program-type',
-    numberOfCourses: 3,
-  },
-  {
-    provider: 'HarvardX',
-    bannerImgSrc: 'https://prod-discovery.edx-cdn.org/media/course/image/327c8e4f-315a-417b-9857-046dfc90c243-677b97464958.small.jpg',
-    logoImgSrc: 'https://prod-discovery.edx-cdn.org/organization/certificate_logos/44022f13-20df-4666-9111-cede3e5dc5b6-770e00385e7e.png',
-    title: 'Relativity in Modern Mechanics',
-    programUrl: 'www.edx/my-program-3',
-    programType: 'MicroBachelors Program',
-    numberOfCourses: 3,
-  },
-  {
-    provider: 'University  of Maryland',
-    bannerImgSrc: 'https://prod-discovery.edx-cdn.org/media/programs/banner_images/9a310b98-8f27-439e-be85-12d6460245c9-f2efca129273.small.jpg',
-    logoImgSrc: 'https://prod-discovery.edx-cdn.org/organization/certificate_logos/b9dc96da-b3fc-45a6-b6b7-b8e12eb79335-ac60112330e3.png',
-    title: 'Pandering for Modern Professionals',
-    programUrl: 'www.edx/my-program-4',
-    programType: 'MicroBachelors Program',
-    programTypeUrl: 'www.edx/my-program-type',
-    numberOfCourses: 3,
-  },
-];
-
-export const genCardId = (index) => `card-id${index}`;
-export const genCourseId = (index) => `course-number${index}-course-id${index}`;
-export const genCourseNumber = (index) => `course-number${index}`;
-export const genCourseShareUrl = (index) => `home.edx.org?social-share-url/${index}`;
-export const genEntitlementUUID = (index) => `entitlement-course-uuid-${index}`;
-
-const bannerImgSrc = '/asset-v1:edX+DemoX+Demo_Course+type@asset+block@images_course_image.jpg';
-
-export const farPastDate = '1900-11-11T00:00:00Z';
-export const pastDate = '2000-11-11T00:00:00Z';
-export const futureDate = '3030-11-11T00:00:00Z';
-export const farFutureDate = '4040-11-11T00:00:00Z';
-export const soonDate = new Date();
-soonDate.setDate(soonDate.getDate() + 60);
-export const soonDateStr = soonDate.toDateString();
-
-export const globalData = {
-  emailConfirmation: {
-    isNeeded: true,
-    sendEmailUrl: 'sendConfirmation@edx.org',
-  },
-  enterpriseDashboard: { label: 'edX, Inc.', url: '/edx-dashboard' },
-  platformSettings: {
-    supportEmail: 'support@example.com',
-    billingEmail: 'billing@email.com',
-    courseSearchUrl: 'edx.com/course-search',
-  },
-  suggestedCourses: [
-    {
-      bannerImgSrc: 'https://prod-discovery.edx-cdn.org/media/programs/banner_images/9a310b98-8f27-439e-be85-12d6460245c9-f2efca129273.small.jpg',
-      courseName: 'Suggested course 1',
-      courseUrl: 'www.edx/suggested-course',
-    },
-    {
-      bannerImgSrc: 'https://prod-discovery.edx-cdn.org/media/programs/banner_images/9a310b98-8f27-439e-be85-12d6460245c9-f2efca129273.small.jpg',
-      courseName: 'Suggested course 2 with a really really really long name for some reason',
-      courseUrl: 'www.edx/suggested-course',
-    },
-    {
-      bannerImgSrc: 'https://prod-discovery.edx-cdn.org/media/programs/banner_images/9a310b98-8f27-439e-be85-12d6460245c9-f2efca129273.small.jpg',
-      courseName: 'Suggested course 3',
-      courseUrl: 'www.edx/suggested-course',
-    },
-    {
-      bannerImgSrc: 'https://prod-discovery.edx-cdn.org/media/programs/banner_images/9a310b98-8f27-439e-be85-12d6460245c9-f2efca129273.small.jpg',
-      courseName: 'Suggested course 4',
-      courseUrl: 'www.edx/suggested-course',
-    },
-  ],
-  socialShareSettings: {
-    facebook: {
-      isEnabled: true,
-      socialBrand: 'edx.org',
-      utmParams: 'utm_campaign=social-sharing-db&utm_medium=social&utm_source=facebook',
-    },
-    twitter: {
-      isEnabled: true,
-      socialBrand: 'edx.org',
-      utmParams: 'utm_campaign=social-sharing-db&utm_medium=social&utm_source=twitter',
-    },
-  },
-};
-
-export const genCourseRunData = (data = {}) => ({
-  isStarted: false,
-  isArchived: false,
-  startDate: data.isStarted ? farPastDate : futureDate,
-  endDate: farFutureDate,
-  minPassingGrade: '0.70',
-  homeUrl: 'edx.com/courses/my-course-url/home',
-  marketingUrl: 'edx.com/courses/my-course-url/marketing',
-  progressUrl: 'edx.com/courses/my-course-url/progress',
-  unenrollUrl: 'edx.com/courses/my-course-url/unenroll',
-  resumeUrl: 'edx.com/courses/my-course-url/resume',
-  ...data,
-});
-
-export const creditData = {
-  providerStatusUrl: 'test-provider-status-url',
-  providerName: 'Credit Provider Name',
-  providerId: 'credit-provider-id',
-  error: false,
-  purchased: false,
-  requestStatus: null,
-};
-
-export const genEnrollmentData = (data = {}) => ({
-  coursewareAccess: {
-    isTooEarly: false,
-    hasUnmetPrerequisites: false,
-    isStaff: false,
-  },
-  accessExpirationDate: ((data.isEnrolled === false) ? null : futureDate),
-  canUpgrade: (data.isVerified ? null : true),
-  hasStarted: false,
-  isAudit: !data.isVerified && (data.isEnrolled !== false),
-  isAuditAccessExpired: data.isVerified ? null : false,
-  isEmailEnabled: false,
-  hasOptedOutOfEmail: false,
-  isEnrolled: true,
-  isVerified: false,
-  ...data,
-});
-
-export const genCertificateData = (data = {}) => ({
-  availableDate: null,
-  isRestricted: false,
-  isEarned: false,
-  isDownloadable: false,
-  certPreviewUrl: 'edx.com/courses/my-course-url/cert-preview',
-  ...data,
-});
-
-export const availableSessions = [
-  {
-    startDate: '2000-01-02T00:00:00Z',
-    endDate: '2020-01-02T00:00:00Z',
-    courseId: genCourseId(1000),
-  },
-  {
-    startDate: '2000-02-03T00:00:00Z',
-    endDate: '2020-02-03T00:00:00Z',
-    courseId: genCourseId(1001),
-  },
-  {
-    startDate: '2000-03-04T00:00:00Z',
-    endDate: '2020-03-04T00:00:00Z',
-    courseId: genCourseId(1002),
-  },
-  {
-    startDate: '2000-04-05T00:00:00Z',
-    endDate: '2020-04-05T00:00:00Z',
-    courseId: genCourseId(1003),
-  },
-  {
-    startDate: '2000-05-06T00:00:00Z',
-    endDate: '2020-05-06T00:00:00Z',
-    courseId: genCourseId(1004),
-  },
-];
-
-const auditCourses = [
-  // audit, course run not started
-  {
-    courseName: 'Audit Course, Course run not started',
-  },
-  // audit, course run not started, too early to view
-  {
-    courseName: 'Audit Course, Course run not started, Too early to view',
-    enrollment: {
-      coursewareAccess: {
-        isTooEarly: true,
-        hasUnmetPrerequisites: false,
-        isStaff: false,
-      },
-    },
-  },
-  // audit, course run not started, too early to view and unmet prereqs
-  {
-    courseName: 'Audit Course, Course run not started, Too early to view, Has unmet prereqs.',
-    enrollment: {
-      coursewareAccess: {
-        isTooEarly: true,
-        hasUnmetPrerequisites: true,
-        isStaff: false,
-      },
-    },
-  },
-  // audit, course run started
-  {
-    courseName: 'Audit Course, Course run not started',
-    courseRun: { isStarted: true },
-  },
-  // audit, course run started, unmet prereqs
-  {
-    courseName: 'Audit Course, Course run not started, Has unmet prereqs',
-    enrollment: {
-      coursewareAccess: {
-        isTooEarly: true,
-        hasUnmetPrerequisites: true,
-        isStaff: false,
-      },
-    },
-    courseRun: { isStarted: true },
-  },
-  // audit, course run started, access expired, learner not started
-  {
-    courseName: 'Audit Course, Course run started, Audit ccess expired, Learner not started',
-    courseRun: { isStarted: true },
-    enrollment: {
-      accessExpirationDate: pastDate,
-      isAuditAccessExpired: true,
-    },
-  },
-  // audit, course run started, access expired, cannot upgrade, learner not started
-  {
-    courseName: 'Audit course, Course run not started, Audit access expired, Cannot upgrade, Learner not started',
-    courseRun: { isStarted: true },
-    enrollment: {
-      accessExpirationDate: pastDate,
-      canUpgrade: false,
-      isAuditAccessExpired: true,
-    },
-  },
-  // audit, course run ended, access expired, cannot upgrade, learner not started
-  {
-    courseName: 'Audit Course, Course run ended, Audit access expired, Cannot upgrade, Learner not started',
-    courseRun: {
-      endDate: pastDate,
-      isStarted: true,
-    },
-    enrollment: {
-      accessExpirationDate: pastDate,
-      isAuditAccessExpired: true,
-    },
-  },
-  // audit, course run archived, access expired, cannot upgrade, learner not started
-  {
-    courseName: 'Audit Course, Course run archived, Audit access expired, Cannot upgrade, Learner not started',
-    courseRun: {
-      endDate: pastDate,
-      isArchived: true,
-      isStarted: true,
-    },
-    enrollment: {
-      accessExpirationDate: pastDate,
-      isAuditAccessExpired: true,
-    },
-  },
-  // audit, course run and learner started, passing
-  {
-    courseName: 'Audit Course, Course run and learner started, Passing',
-    courseRun: { isStarted: true },
-    enrollment: { hasStarted: true },
-  },
-  // audit, course run and learner started, access expired
-  {
-    courseName: 'Audit Course, Course run and learner started, Audit access expired',
-    courseRun: { isStarted: true },
-    enrollment: {
-      accessExpirationDate: pastDate,
-      isAuditAccessExpired: true,
-      hasStarted: true,
-    },
-  },
-  // audit, course run and learner started, access expired, cannot upgrade
-  {
-    courseName: 'Audit Course, Course run and learner started, Audit access expired, Cannot upgrade',
-    courseRun: { isStarted: true },
-    enrollment: {
-      accessExpirationDate: pastDate,
-      canUpgrade: false,
-      isAuditAccessExpired: true,
-      hasStarted: true,
-    },
-  },
-  // audit, course run ended, learner started, expired, cannot upgraded, not passing
-  {
-    courseName: 'Audit Course, Course run ended, Learner started, Access expired, Cannot upgrade, Not passing',
-    courseRun: {
-      isStarted: true,
-      endDate: pastDate,
-    },
-    enrollment: {
-      accessExpirationDate: pastDate,
-      canUpgrade: false,
-      isAuditAccessExpired: true,
-      hasStarted: true,
-    },
-    grade: { isPassing: false },
-  },
-  // audit, course run archived, learner started, expired, cannot upgrade, not passing
-  {
-    courseName: 'Audit Course, Course run archived, Learner started, Access expired, Cannot upgrade, Not passing',
-    courseRun: {
-      isStarted: true,
-      isArchived: true,
-      endDate: pastDate,
-    },
-    enrollment: {
-      accessExpirationDate: pastDate,
-      canUpgrade: false,
-      isAuditAccessExpired: true,
-      hasStarted: true,
-    },
-    grade: { isPassing: false },
-  },
-];
-const verifiedCourses = [
-  // verified, course not started, learner not started
-  {
-    courseName: 'Verified Course, Course and learner not started',
-    enrollment: { isVerified: true },
-  },
-  // verified, course started, learner not started
-  {
-    courseName: 'Verified Course, Course started, Learner not started',
-    courseRun: { isStarted: true },
-    enrollment: { isVerified: true },
-  },
-  // verified, course started, learner started, passing
-  {
-    courseName: 'Verified Course, Course and learner started, Passing',
-    courseRun: { isStarted: true },
-    enrollment: { hasStarted: true, isVerified: true },
-  },
-  // verified, course started, learner started, not passing
-  {
-    courseName: 'Verified Course, Course and learner started, not passing',
-    courseRun: { isStarted: true },
-    gradeData: { isPassing: false },
-    enrollment: { hasStarted: true, isVerified: true },
-  },
-  // verified, learner finished, not passing, cert not earned
-  {
-    courseName: 'Verified Course, Learner finished, cert not earned',
-    enrollment: {
-      hasStarted: true,
-      isVerified: true,
-    },
-    courseRun: { isStarted: true, isArchived: true },
-    gradeData: { isPassing: false },
-    certificate: {
-      isEarned: false,
-    },
-  },
-  // verified, learner finished, passing, cert earned but not available
-  {
-    courseName: 'Verified Course, Learner finished, Cert earned but not available',
-    enrollment: {
-      hasStarted: true,
-      isVerified: true,
-    },
-    courseRun: { isStarted: true, isArchived: true },
-    certificate: {
-      isEarned: true,
-      availableDate: futureDate,
-    },
-  },
-  // verified, learner finished, passing, restricted
-  {
-    courseName: 'Verified Course, Learner finished, Passing, Certificate restricted',
-    enrollment: {
-      hasStarted: true,
-      isVerified: true,
-    },
-    courseRun: { isStarted: true, isArchived: true },
-    certificate: { isRestricted: true },
-  },
-  // verified, learner finished, cert earned, downloadable (web + link)
-  {
-    courseName: 'Verified Course, Learner finished, Passing, Certificate downloadable and viewable',
-    enrollment: {
-      hasStarted: true,
-      isVerified: true,
-    },
-    courseRun: { isStarted: true, isArchived: true },
-    certificate: {
-      isEarned: true,
-      isDownloadable: true,
-      availableDate: pastDate,
-      certPreviewUrl: bannerImgSrc,
-    },
-  },
-  // verified, course ended, learner finished, cert earned, downloadable (link only),
-  {
-    courseName: 'Verified Course, Course ended, Learner finished, Passing, Certificate downloadable',
-    enrollment: {
-      hasStarted: true,
-      isVerified: true,
-    },
-    courseRun: {
-      isStarted: true,
-      isArchived: true,
-      endDate: pastDate,
-    },
-    certificate: {
-      isEarned: true,
-      isDownloadable: true,
-      availableDate: pastDate,
-    },
-  },
-  // verified, course ended, learner finished, cert earned, downloadable (web + link)
-  {
-    courseName: 'Verified Course, Course ended, Learner finished, Passing, Certificate downloadable and viewable',
-    enrollment: {
-      hasStarted: true,
-      isVerified: true,
-    },
-    courseRun: {
-      isStarted: true,
-      isArchived: true,
-      endDate: pastDate,
-    },
-    certificate: {
-      isEarned: true,
-      isDownloadable: true,
-      availableDate: pastDate,
-      certPreviewUrl: bannerImgSrc,
-    },
-  },
-];
-const fulfilledEntitlementCourses = [
-  // Entitlement - not started
-  {
-    courseName: 'Entitlement Course, not started',
-    enrollment: {
-      isVerified: true,
-      coursewareAccess: {
-        isTooEarly: true,
-        hasUnmetPrerequisites: false,
-        isStaff: false,
-      },
-    },
-    courseRun: { isStarted: false },
-    entitlement: {
-      uuid: genEntitlementUUID(0),
-      availableSessions,
-      changeDeadline: futureDate,
-      enrollmentUrl: '/entitlement-enrollment',
-      isExpired: false,
-      isFulfilled: true,
-      isRefundable: true,
-    },
-  },
-  // Entitlement - Course run started, learner not started, unmet prereqs
-  {
-    courseName: 'Entitlement Course, Course run started, Learner not started, Has unmet prereqs',
-    enrollment: {
-      isVerified: true,
-      coursewareAccess: {
-      },
-    },
-    courseRun: { isStarted: true },
-    entitlement: {
-      uuid: genEntitlementUUID(1),
-      availableSessions,
-      changeDeadline: futureDate,
-      enrollmentUrl: '/entitlement-enrollment',
-      isExpired: false,
-      isFulfilled: true,
-      isRefundable: true,
-    },
-  },
-  // Entitlement - Course run started, learner started, not passing
-  {
-    courseName: 'Entitlement Course, Course run started, Learner started, Not passing',
-    enrollment: {
-      isVerified: true,
-      hasStarted: true,
-    },
-    courseRun: { isStarted: true },
-    entitlement: {
-      uuid: genEntitlementUUID(2),
-      availableSessions,
-      changeDeadline: futureDate,
-      enrollmentUrl: '/entitlement-enrollment',
-      isExpired: false,
-      isFulfilled: true,
-      isRefundable: true,
-    },
-    gradeData: { isPassing: false },
-  },
-  // Entitlement - Course run started, learner started, passing, cannot change
-  {
-    courseName: 'Entitlement Course, Course run and learner started, Passing, Cannot change sessions',
-    enrollment: {
-      isVerified: true,
-      hasStarted: true,
-    },
-    courseRun: { isStarted: true },
-    entitlement: {
-      uuid: genEntitlementUUID(3),
-      availableSessions,
-      changeDeadline: pastDate,
-      enrollmentUrl: '/entitlement-enrollment',
-      isExpired: false,
-      isFulfilled: true,
-      isRefundable: true,
-    },
-  },
-  // Entitlement - Learner finished, but did not pass
-  {
-    courseName: 'Entitlement Course, Learner finished but did not pass',
-    enrollment: {
-      isVerified: true,
-    },
-    courseRun: { isStarted: true, isArchived: false },
-    entitlement: {
-      uuid: genEntitlementUUID(4),
-      availableSessions: null,
-      changeDeadline: pastDate,
-      enrollmentUrl: '/entitlement-enrollment',
-      isExpired: false,
-      isFulfilled: true,
-      isRefundable: false,
-    },
-    gradeData: { isPassing: false },
-  },
-  // Entitlement - Learner finished, and passed.  cannot refund.  previewable cert.
-  {
-    courseName: 'Entitlement course, Learner finished and passed, Cannot refund, Previewable Cert',
-    enrollment: {
-      isVerified: true,
-    },
-    courseRun: { isStarted: true, isArchived: false },
-    entitlement: {
-      uuid: genEntitlementUUID(5),
-      availableSessions: null,
-      changeDeadline: pastDate,
-      enrollmentUrl: '/entitlement-enrollment',
-      isExpired: false,
-      isFulfilled: true,
-      isRefundable: false,
-    },
-    certificate: {
-      isEarned: true,
-      isDownloadable: true,
-      availableDate: pastDate,
-      certPreviewUrl: bannerImgSrc,
-    },
-  },
-  // Entitlement - Learner finished and failed.  cannot refund.  course ended.
-  {
-    courseName: 'Entitlement Course, Learner finished and failed, Cannot refund, Course ended',
-    enrollment: {
-      isVerified: true,
-    },
-    courseRun: {
-      isStarted: true,
-      isArchived: false,
-      endDate: pastDate,
-    },
-    entitlement: {
-      uuid: genEntitlementUUID(6),
-      availableSessions: null,
-      enrollmentUrl: '/entitlement-enrollment',
-      isFulfilled: true,
-      isRefundable: false,
-      changeDeadline: pastDate,
-      isExpired: false,
-    },
-    gradeData: { isPassing: false },
-  },
-  // Entitlement - Learner finished and passed.  cannot refund.  cert downloadable
-  {
-    courseName: 'Entitlement Course, Learner finished and passed, Cannot refund, Cert downloadable',
-    enrollment: {
-      isVerified: true,
-    },
-    courseRun: {
-      isArchived: true,
-      isStarted: true,
-      endDate: pastDate,
-    },
-    entitlement: {
-      uuid: genEntitlementUUID(7),
-      availableSessions: null,
-      changeDeadline: pastDate,
-      enrollmentUrl: '/entitlement-enrollment',
-      isExpired: false,
-      isRefundable: false,
-      isFulfilled: true,
-    },
-    certificate: {
-      isEarned: true,
-      isDownloadable: true,
-      availableDate: pastDate,
-      certPreviewUrl: bannerImgSrc,
-    },
-  },
-];
-const creditCourses = [
-  {
-    courseName: 'Credit - Eligible for credit from unknown provider',
-    credit: {
-      ...creditData,
-      providerName: null,
-      providerId: null,
-    },
-    enrollment: { isEnrolled: true },
-  },
-  {
-    courseName: 'Credit - Eligible for credit from known provider',
-    credit: creditData,
-    enrollment: { isEnrolled: true },
-  },
-  {
-    courseName: 'Credit - Purchased but must request',
-    credit: { ...creditData, purchased: true },
-    enrollment: { isEnrolled: true },
-  },
-  {
-    courseName: 'Credit - Credit Request Pending',
-    credit: {
-      ...creditData,
-      purchased: true,
-      requestStatus: creditVals.requestStatuses.pending,
-    },
-    enrollment: { isEnrolled: true },
-  },
-  {
-    courseName: 'Credit - Credit Request Approved',
-    credit: {
-      ...creditData,
-      purchased: true,
-      requestStatus: creditVals.requestStatuses.approved,
-    },
-    enrollment: { isEnrolled: true },
-  },
-  {
-    courseName: 'Credit - Credit Request Rejected, Error thrown',
-    credit: {
-      ...creditData,
-      purchased: true,
-      requestStatus: creditVals.requestStatuses.rejected,
-      error: true,
-    },
-    enrollment: { isEnrolled: true },
-  },
-];
-
-export const courseRuns = [
-  ...auditCourses,
-  ...verifiedCourses,
-  ...fulfilledEntitlementCourses,
-  ...creditCourses,
-];
-
-// unfulfilled entitlement select session
-// unfulfilled entitlement select session with deadline
-// unfulfilled entitlement select session pass deadline with available session {banner different from 4th}
-// unfulfilled entitlement select session pass deadline without available session
-export const entitlementCourses = [
-  {
-    courseName: 'Unfulfilled Entitlement select session',
-    entitlement: {
-      uuid: genEntitlementUUID(10),
-      availableSessions,
-      changeDeadline: futureDate,
-      enrollmentUrl: '/entitlement-enrollment',
-      isExpired: false,
-      isFulfilled: false,
-      isRefundable: true,
-    },
-  }, {
-    courseName: 'Unfulfilled Entitlement select session with upcoming deadline',
-    entitlement: {
-      uuid: genEntitlementUUID(11),
-      availableSessions,
-      changeDeadline: soonDateStr,
-      enrollmentUrl: '/entitlement-enrollment',
-      isExpired: false,
-      isFulfilled: false,
-      isRefundable: true,
-    },
-  }, {
-    courseName: 'Unfulfilled Entitlement select session past deadline, With available session',
-    entitlement: {
-      uuid: genEntitlementUUID(12),
-      availableSessions,
-      changeDeadline: pastDate,
-      enrollmentUrl: '/entitlement-enrollment',
-      isExpired: false,
-      isFulfilled: false,
-      isRefundable: true,
-    },
-  }, {
-    courseName: 'Unfulfilled Entitlement select session past deadline, With available no session',
-    entitlement: {
-      uuid: genEntitlementUUID(13),
-      availableSessions: [],
-      changeDeadline: pastDate,
-      enrollmentUrl: '/entitlement-enrollment',
-      isExpired: true,
-      isFulfilled: false,
-      isRefundable: true,
-    },
-  },
-];
-
-const providerOptions = [
-  providers.edx,
-  providers.mit,
-  null,
-];
-
-const emailOptions = [
-  { isEmailEnabled: false, hasOptedOutOfEmail: false },
-  { isEmailEnabled: true, hasOptedOutOfEmail: false },
-  { isEmailEnabled: true, hasOptedOutOfEmail: true },
-];
-
-const programsOptions = [
-  { relatedPrograms },
-  { relatedPrograms: [relatedPrograms[0]] },
-  { relatedPrograms: [] },
-];
-
-const getOption = (options, index) => options[index % options.length];
-
-export const compileCourseRunData = ({ courseName, ...data }, index) => {
-  const courseId = genCourseId(index);
-  const courseNumber = genCourseNumber(index);
-  const socialShareUrl = genCourseShareUrl(index);
-  const lastEnrolledDate = new Date();
-  lastEnrolledDate.setDate(lastEnrolledDate.getDate() - index - 1);
-  const lastEnrolled = lastEnrolledDate.toISOString();
-  const out = {
-    gradeData: { isPassing: true },
-    entitlement: null,
-    credit: {},
-    ...data,
-    certificate: genCertificateData(data.certificate),
-    enrollment: genEnrollmentData({
-      lastEnrolled,
-      ...getOption(emailOptions, index),
-      ...data.enrollment,
-    }),
-    courseRun: genCourseRunData({
-      ...data.courseRun,
-      courseId,
-    }),
-    course: {
-      courseName,
-      bannerImgSrc,
-      courseNumber,
-      socialShareUrl,
-    },
-    courseProvider: getOption(providerOptions, index),
-    programs: getOption(programsOptions, index),
-  };
-  return out;
-};
-
-export const compileEntitlementData = ({ courseName, ...data }, index) => {
-  const courseNumber = genCourseNumber(100 + index);
-  const socialShareUrl = genCourseShareUrl(100 + index);
-  return {
-    enrollment: genEnrollmentData({
-      isEnrolled: false,
-      lastEnrolled: null,
-      accessExpirationDate: null,
-      canUpgrade: false,
-      hasStarted: false,
-      isAudit: false,
-      isAuditAccessExpired: false,
-      isEmailEnabled: false,
-      isVerified: false,
-    }),
-    gradeData: null,
-    certificate: null,
-    courseRun: null,
-    ...data,
-    course: {
-      courseName,
-      courseNumber,
-      bannerImgSrc,
-      socialShareUrl,
-    },
-    courseProvider: getOption(providerOptions, index),
-    programs: getOption(programsOptions, index),
-  };
-};
-
-// Entitlement Course - refundable
-// Entitlement Course - cannot view yet
-// Entitlement Course - can view and change
-// Entitlement Course - expired
-export const courseRunData = courseRuns.map(compileCourseRunData);
-export const entitlementData = entitlementCourses.map(compileEntitlementData);
-
-export default {
-  compileEntitlementData,
-  compileCourseRunData,
-  courseRunData,
-  entitlementData,
-  globalData,
-};
diff --git a/src/data/services/lms/fakeData/testUtils.js b/src/data/services/lms/fakeData/testUtils.js
deleted file mode 100644
index c471ef6c6..000000000
--- a/src/data/services/lms/fakeData/testUtils.js
+++ /dev/null
@@ -1,40 +0,0 @@
-// import { StrictDict } from 'utils';
-import {
-  ErrorStatuses,
-  // RequestKeys,
-} from 'data/constants/requests';
-import { actions } from 'data/redux';
-
-export const errorData = (status, data = '') => ({
-  response: {
-    status,
-    data,
-  },
-});
-
-export const networkErrorData = errorData(ErrorStatuses.badRequest);
-
-export const genTestUtils = ({
-  dispatch,
-}) => {
-  /*
-  const mockStart = (requestKey) => () => {
-    dispatch(actions.requests.startRequest(requestKey));
-  };
-  */
-
-  const mockError = (requestKey, status, data) => () => {
-    dispatch(actions.requests.failRequest({
-      requestKey,
-      error: errorData(status, data),
-    }));
-  };
-  const mockNetworkError = (requestKey) => (
-    mockError(requestKey, ErrorStatuses.badRequest)
-  );
-  return {
-    mockNetworkError,
-  };
-};
-
-export default genTestUtils;
diff --git a/src/data/store.js b/src/data/store.js
deleted file mode 100755
index 8df4af52e..000000000
--- a/src/data/store.js
+++ /dev/null
@@ -1,37 +0,0 @@
-import * as redux from 'redux';
-import thunkMiddleware from 'redux-thunk';
-import {
-  composeWithDevToolsLogOnlyInProduction,
-} from '@redux-devtools/extension';
-import { createLogger } from 'redux-logger';
-
-import apiTestUtils from 'data/services/lms/fakeData/testUtils';
-
-import reducer, { actions, selectors } from './redux';
-
-export const createStore = () => {
-  const loggerMiddleware = createLogger();
-
-  const middleware = [thunkMiddleware, loggerMiddleware];
-
-  const store = redux.createStore(
-    reducer,
-    composeWithDevToolsLogOnlyInProduction(redux.applyMiddleware(...middleware)),
-  );
-
-  /**
-   * Dev tools for redux work
-   */
-  if (process.env.NODE_ENV === 'development') {
-    window.store = store;
-    window.actions = actions;
-    window.selectors = selectors;
-    window.apiTestUtils = apiTestUtils(store);
-  }
-
-  return store;
-};
-
-const store = createStore();
-
-export default store;
diff --git a/src/data/store.test.js b/src/data/store.test.js
deleted file mode 100644
index cd789bc4b..000000000
--- a/src/data/store.test.js
+++ /dev/null
@@ -1,68 +0,0 @@
-import { applyMiddleware } from 'redux';
-import thunkMiddleware from 'redux-thunk';
-import {
-  composeWithDevToolsLogOnlyInProduction,
-} from '@redux-devtools/extension';
-import { createLogger } from 'redux-logger';
-
-import rootReducer, { actions, selectors } from 'data/redux';
-
-import exportedStore, { createStore } from './store';
-
-jest.mock('data/redux', () => ({
-  __esModule: true,
-  default: 'REDUCER',
-  actions: 'ACTIONS',
-  selectors: 'SELECTORS',
-}));
-
-jest.mock('redux-logger', () => ({
-  createLogger: () => 'logger',
-}));
-jest.mock('redux-thunk', () => 'thunkMiddleware');
-jest.mock('redux', () => ({
-  applyMiddleware: (...middleware) => ({ applied: middleware }),
-  createStore: (reducer, middleware) => ({ reducer, middleware }),
-}));
-jest.mock('@redux-devtools/extension', () => ({
-  composeWithDevToolsLogOnlyInProduction: (middleware) => ({ withDevTools: middleware }),
-}));
-
-describe('store aggregator module', () => {
-  describe('exported store', () => {
-    it('is generated by createStore', () => {
-      expect(exportedStore).toEqual(createStore());
-    });
-    it('creates store with connected reducers', () => {
-      expect(createStore().reducer).toEqual(rootReducer);
-    });
-    describe('middleware', () => {
-      it('exports thunk and logger middleware, composed and applied with dev tools', () => {
-        expect(createStore().middleware).toEqual(
-          composeWithDevToolsLogOnlyInProduction(applyMiddleware(thunkMiddleware, createLogger())),
-        );
-      });
-    });
-  });
-  describe('dev exposed tools', () => {
-    beforeEach(() => {
-      window.store = undefined;
-      window.actions = undefined;
-      window.selectors = undefined;
-    });
-    it('exposes redux tools if in development env', () => {
-      process.env.NODE_ENV = 'development';
-      const store = createStore();
-      expect(window.store).toEqual(store);
-      expect(window.actions).toEqual(actions);
-      expect(window.selectors).toEqual(selectors);
-    });
-    it('does not expose redux tools if in production env', () => {
-      process.env.NODE_ENV = 'production';
-      createStore();
-      expect(window.store).toEqual(undefined);
-      expect(window.actions).toEqual(undefined);
-      expect(window.selectors).toEqual(undefined);
-    });
-  });
-});
diff --git a/src/data/utils.js b/src/data/utils.js
deleted file mode 100644
index 40bcfc4b1..000000000
--- a/src/data/utils.js
+++ /dev/null
@@ -1,19 +0,0 @@
-/**
- * Simple selector factory.
- * Takes a list of string keys, and returns a simple slector for each.
- *
- * @function
- * @param {Object|string[]} keys - If passed as object, Object.keys(keys) is used.
- * @return {Object} - object of `{[key]: ({key}) => key}`
- */
-const simpleSelectorFactory = (transformer, keys) => {
-  const selKeys = Array.isArray(keys) ? keys : Object.keys(keys);
-  return selKeys.reduce(
-    (obj, key) => ({
-      ...obj, [key]: (state) => transformer(state)[key],
-    }),
-    { root: (state) => transformer(state) },
-  );
-};
-
-export default simpleSelectorFactory;
diff --git a/src/data/utils.test.js b/src/data/utils.test.js
deleted file mode 100644
index fd870d259..000000000
--- a/src/data/utils.test.js
+++ /dev/null
@@ -1,29 +0,0 @@
-import simpleSelectorFactory from './utils';
-
-describe('Redux utilities - creators', () => {
-  describe('simpleSelectors', () => {
-    const data = { a: 1, b: 2, c: 3 };
-    const state = {
-      testGroup: data,
-      other: 'stuff',
-    };
-    const transformer = ({ testGroup }) => testGroup;
-
-    test('given a list of strings, returns a dict w/ a simple selector per string', () => {
-      const keys = ['a', 'b'];
-      const selectors = simpleSelectorFactory(transformer, keys);
-      expect(Object.keys(selectors)).toEqual(['root', ...keys]);
-      expect(selectors.root(state)).toEqual(data);
-      expect(selectors.a(state)).toEqual(data.a);
-      expect(selectors.b(state)).toEqual(data.b);
-    });
-    test('given an object for keys, returns a dict w/ simple selector per key', () => {
-      const selectors = simpleSelectorFactory(transformer, data);
-      expect(Object.keys(selectors)).toEqual(['root', ...Object.keys(data)]);
-      expect(selectors.root(state)).toEqual(data);
-      expect(selectors.a(state)).toEqual(data.a);
-      expect(selectors.b(state)).toEqual(data.b);
-      expect(selectors.c(state)).toEqual(data.c);
-    });
-  });
-});
diff --git a/src/hooks/api.js b/src/hooks/api.js
deleted file mode 100644
index d64a11850..000000000
--- a/src/hooks/api.js
+++ /dev/null
@@ -1,105 +0,0 @@
-import React from 'react';
-
-import { AppContext } from '@edx/frontend-platform/react';
-
-import { RequestKeys } from 'data/constants/requests';
-import { post } from 'data/services/lms/utils';
-import api from 'data/services/lms/api';
-
-import * as reduxHooks from 'data/redux/hooks';
-import * as module from './api';
-
-const { useMakeNetworkRequest } = reduxHooks;
-
-export const useNetworkRequest = (action, args) => {
-  const makeNetworkRequest = useMakeNetworkRequest();
-  return (...actionsArgs) => makeNetworkRequest({
-    promise: action(...actionsArgs),
-    ...args,
-  });
-};
-
-/**
- * initialize the app, loading ora and course metadata from the api, and loading the initial
- * submission list data.
- */
-export const useInitializeApp = () => {
-  const loadData = reduxHooks.useLoadData();
-  return module.useNetworkRequest(api.initializeList, {
-    requestKey: RequestKeys.initialize,
-    onSuccess: ({ data }) => loadData(data),
-  });
-};
-
-export const useNewEntitlementEnrollment = (cardId) => {
-  const { uuid } = reduxHooks.useCardEntitlementData(cardId);
-  const onSuccess = module.useInitializeApp();
-  return module.useNetworkRequest(
-    (selection) => api.updateEntitlementEnrollment({ uuid, courseId: selection }),
-    { onSuccess, requestKey: RequestKeys.newEntitlementEnrollment },
-  );
-};
-
-export const useSwitchEntitlementEnrollment = (cardId) => {
-  const { uuid } = reduxHooks.useCardEntitlementData(cardId);
-  const onSuccess = module.useInitializeApp();
-  const action = (selection) => api.updateEntitlementEnrollment({ uuid, courseId: selection });
-  return module.useNetworkRequest(
-    action,
-    { onSuccess, requestKey: RequestKeys.switchEntitlementSession },
-  );
-};
-
-export const useLeaveEntitlementSession = (cardId) => {
-  const { uuid, isRefundable } = reduxHooks.useCardEntitlementData(cardId);
-  const onSuccess = module.useInitializeApp();
-  return module.useNetworkRequest(
-    () => api.deleteEntitlementEnrollment({ uuid, isRefundable }),
-    { onSuccess, requestKey: RequestKeys.leaveEntitlementSession },
-  );
-};
-
-export const useUnenrollFromCourse = (cardId) => {
-  const { courseId } = reduxHooks.useCardCourseRunData(cardId);
-  return module.useNetworkRequest(
-    () => api.unenrollFromCourse({ courseId }),
-    { requestKey: RequestKeys.unenrollFromCourse },
-  );
-};
-
-export const useMasqueradeAs = () => {
-  const loadData = reduxHooks.useLoadData();
-  return module.useNetworkRequest(
-    (user) => api.initializeList({ user }),
-    { onSuccess: ({ data }) => loadData(data), requestKey: RequestKeys.masquerade },
-  );
-};
-
-export const useClearMasquerade = () => {
-  const clearRequest = reduxHooks.useClearRequest();
-  const initializeApp = module.useInitializeApp();
-  return () => {
-    clearRequest(RequestKeys.masquerade);
-    initializeApp();
-  };
-};
-
-export const useUpdateEmailSettings = (cardId) => {
-  const { courseId } = reduxHooks.useCardCourseRunData(cardId);
-  return module.useNetworkRequest(
-    (enable) => api.updateEmailSettings({ courseId, enable }),
-    { requestKey: RequestKeys.updateEmailSettings },
-  );
-};
-
-export const useSendConfirmEmail = () => {
-  const { sendEmailUrl } = reduxHooks.useEmailConfirmationData();
-  return () => post(sendEmailUrl);
-};
-
-export const useCreateCreditRequest = (cardId) => {
-  const { providerId } = reduxHooks.useCardCreditData(cardId);
-  const { authenticatedUser: { username } } = React.useContext(AppContext);
-  const { courseId } = reduxHooks.useCardCourseRunData(cardId);
-  return () => api.createCreditRequest({ providerId, courseId, username });
-};
diff --git a/src/hooks/api.test.js b/src/hooks/api.test.js
deleted file mode 100644
index ebe7c5eb4..000000000
--- a/src/hooks/api.test.js
+++ /dev/null
@@ -1,275 +0,0 @@
-import React from 'react';
-import { AppContext } from '@edx/frontend-platform/react';
-import { keyStore } from 'utils';
-import { RequestKeys } from 'data/constants/requests';
-import { post } from 'data/services/lms/utils';
-import api from 'data/services/lms/api';
-
-import * as reduxHooks from 'data/redux/hooks';
-import * as apiHooks from './api';
-
-const reduxKeys = keyStore(reduxHooks);
-
-jest.mock('data/services/lms/utils', () => ({
-  post: jest.fn((...args) => ({ post: args })),
-}));
-jest.mock('data/services/lms/api', () => ({
-  initializeList: jest.fn(),
-  updateEntitlementEnrollment: jest.fn(),
-  unenrollFromCourse: jest.fn(),
-  deleteEntitlementEnrollment: jest.fn(),
-  updateEmailSettings: jest.fn(),
-  createCreditRequest: jest.fn(),
-}));
-jest.mock('data/redux/hooks', () => ({
-  useCardCourseRunData: jest.fn(),
-  useCardCreditData: jest.fn(),
-  useCardEntitlementData: jest.fn(),
-  useLoadData: jest.fn(),
-  useMakeNetworkRequest: jest.fn(),
-  useClearRequest: jest.fn(),
-  useEmailConfirmationData: jest.fn(),
-}));
-jest.mock('react', () => ({
-  ...jest.requireActual('react'),
-  useContext: jest.fn(context => context),
-}));
-
-const moduleKeys = keyStore(apiHooks);
-const testString = 'TEST-string';
-const uuid = 'test-UUID';
-const cardId = 'test-card-id';
-const selection = 'test-selection';
-const courseId = 'test-COURSE-id';
-const isRefundable = 'test-is-refundable';
-const user = 'test-user';
-
-const loadData = jest.fn();
-reduxHooks.useLoadData.mockReturnValue(loadData);
-const clearRequest = jest.fn();
-reduxHooks.useClearRequest.mockReturnValue(clearRequest);
-
-reduxHooks.useCardCourseRunData.mockReturnValue({ courseId });
-reduxHooks.useCardEntitlementData.mockReturnValue({ uuid, isRefundable });
-
-let hook;
-let out;
-
-const testInitCardHook = (hookKey) => {
-  test(`initializes ${hookKey} with cardId`, () => {
-    expect(reduxHooks[hookKey]).toHaveBeenCalledWith(cardId);
-  });
-};
-
-const initializeApp = jest.fn();
-
-describe('api hooks', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('useNetworkRequest', () => {
-    const makeNetworkRequest = jest.fn(args => ({ networkRequest: args }));
-    const action = jest.fn((...actionArgs) => ({ action: actionArgs }));
-    const args = { some: 'test', args: 'for you' };
-    it('returns network request based on incoming action', () => {
-      reduxHooks.useMakeNetworkRequest.mockReturnValue(makeNetworkRequest);
-      hook = apiHooks.useNetworkRequest(action, args);
-      expect(hook()).toEqual(makeNetworkRequest({ promise: action(), ...args }));
-    });
-    it('forwards action arguments', () => {
-      reduxHooks.useMakeNetworkRequest.mockReturnValue(makeNetworkRequest);
-      hook = apiHooks.useNetworkRequest(action, args);
-      const actionArgs = [1, 2, 3];
-      expect(hook(...actionArgs)).toEqual(
-        makeNetworkRequest({ promise: action(...actionArgs), ...args }),
-      );
-    });
-  });
-
-  describe('network requests', () => {
-    const mockUseNetworkRequest = jest.fn((action, args) => ({ action, args }));
-    const testRequestKey = (requestKey) => {
-      test('requestKey', () => { expect(hook.args.requestKey).toEqual(requestKey); });
-    };
-
-    beforeEach(() => {
-      jest.spyOn(apiHooks, moduleKeys.useNetworkRequest).mockImplementation(mockUseNetworkRequest);
-    });
-
-    describe('useInitializeApp', () => {
-      beforeEach(() => {
-        hook = apiHooks.useInitializeApp();
-      });
-      it('calls initialize api method', () => {
-        expect(hook.action).toEqual(api.initializeList);
-      });
-      testRequestKey(RequestKeys.initialize);
-      it('initializes load data hook', () => {
-        expect(reduxHooks.useLoadData).toHaveBeenCalledWith();
-      });
-      it('calls loadData with data on success', () => {
-        hook.args.onSuccess({ data: testString });
-        expect(loadData).toHaveBeenCalledWith(testString);
-      });
-    });
-
-    describe('entitlement enrollment hooks', () => {
-      beforeEach(() => {
-        jest.spyOn(apiHooks, moduleKeys.useInitializeApp).mockReturnValue(initializeApp);
-      });
-
-      const testInitialization = () => {
-        it('initializes useInitializeApp', () => {
-          expect(apiHooks.useInitializeApp).toHaveBeenCalledWith();
-        });
-        testInitCardHook(reduxKeys.useCardEntitlementData);
-      };
-
-      const testArgs = (requestKey) => {
-        testRequestKey(requestKey);
-        it('initializes app on success', () => {
-          expect(hook.args.onSuccess).toEqual(initializeApp);
-        });
-      };
-
-      describe('useNewEntitlementEnrollment', () => {
-        beforeEach(() => {
-          hook = apiHooks.useNewEntitlementEnrollment(cardId);
-        });
-        testInitialization();
-        testArgs(RequestKeys.newEntitlementEnrollment);
-        it('calls updateEntitlementEnrollment api method', () => {
-          hook.action(selection);
-          expect(api.updateEntitlementEnrollment)
-            .toHaveBeenCalledWith({ uuid, courseId: selection });
-        });
-      });
-
-      describe('useSwitchEntitlementEnrollment', () => {
-        beforeEach(() => {
-          hook = apiHooks.useSwitchEntitlementEnrollment(cardId);
-        });
-        testInitialization();
-        testArgs(RequestKeys.switchEntitlementSession);
-        it('calls updateEntitlementEnrollment api method', () => {
-          hook.action(selection);
-          expect(api.updateEntitlementEnrollment)
-            .toHaveBeenCalledWith({ uuid, courseId: selection });
-        });
-      });
-
-      describe('useLeaveEntitlementSession', () => {
-        beforeEach(() => {
-          hook = apiHooks.useLeaveEntitlementSession(cardId);
-        });
-        testInitialization();
-        testArgs(RequestKeys.leaveEntitlementSession);
-        it('calls updateEntitlementEnrollment api method', () => {
-          hook.action();
-          expect(api.deleteEntitlementEnrollment)
-            .toHaveBeenCalledWith({ uuid, isRefundable });
-        });
-      });
-    });
-
-    describe('useUnenrollFromCourse', () => {
-      beforeEach(() => {
-        hook = apiHooks.useUnenrollFromCourse(cardId);
-      });
-      testInitCardHook(reduxKeys.useCardCourseRunData);
-      testRequestKey(RequestKeys.unenrollFromCourse);
-      it('calls unenrollFromCourse api method with courseId', () => {
-        hook.action();
-        expect(api.unenrollFromCourse).toHaveBeenCalledWith({ courseId });
-      });
-    });
-
-    describe('useMasqueradeAs', () => {
-      beforeEach(() => {
-        hook = apiHooks.useMasqueradeAs(cardId);
-      });
-      it('initializes load data hook', () => {
-        expect(reduxHooks.useLoadData).toHaveBeenCalledWith();
-      });
-      testRequestKey(RequestKeys.masquerade);
-      it('calls initializeList api method', () => {
-        hook.action(user);
-        expect(api.initializeList).toHaveBeenCalledWith({ user });
-      });
-      it('loads data on success', () => {
-        hook.args.onSuccess({ data: testString });
-        expect(loadData).toHaveBeenCalledWith(testString);
-      });
-    });
-
-    describe('useClearMasquerade', () => {
-      beforeEach(() => {
-        jest.spyOn(apiHooks, moduleKeys.useInitializeApp).mockReturnValue(initializeApp);
-        hook = apiHooks.useClearMasquerade(cardId);
-      });
-      it('initializes clear request redux hook', () => {
-        expect(reduxHooks.useClearRequest).toHaveBeenCalledWith();
-      });
-      it('initializes useInitializeApp hook', () => {
-        expect(apiHooks.useInitializeApp).toHaveBeenCalledWith();
-      });
-      it('clears masquerade state and initializes app on call', () => {
-        hook();
-        expect(clearRequest).toHaveBeenCalledWith(RequestKeys.masquerade);
-        expect(initializeApp).toHaveBeenCalledWith();
-      });
-    });
-
-    describe('useUpdateEmailSettings', () => {
-      const enable = 'test-enable';
-      beforeEach(() => {
-        hook = apiHooks.useUpdateEmailSettings(cardId);
-      });
-      testInitCardHook(reduxKeys.useCardCourseRunData);
-      testRequestKey(RequestKeys.updateEmailSettings);
-      it('calls updateEmailSettings api method on call', () => {
-        hook.action(enable);
-        expect(api.updateEmailSettings).toHaveBeenCalledWith({ courseId, enable });
-      });
-    });
-
-    describe('useSendConfirmEmail', () => {
-      const sendEmailUrl = 'test-send-email-url';
-      beforeEach(() => {
-        reduxHooks.useEmailConfirmationData.mockReturnValue({ sendEmailUrl });
-        hook = apiHooks.useSendConfirmEmail(cardId);
-        out = hook();
-      });
-      it('initializes useEmailConfirmationData hook', () => {
-        expect(reduxHooks.useEmailConfirmationData).toHaveBeenCalledWith();
-      });
-      it('posts to email url on call', () => {
-        expect(out).toEqual(post(sendEmailUrl));
-      });
-    });
-
-    describe('useCreateCreditRequest', () => {
-      const username = 'test-username';
-      const providerId = 'test-provider-id';
-      beforeEach(() => {
-        React.useContext.mockReturnValue({ authenticatedUser: { username } });
-        reduxHooks.useCardCreditData.mockReturnValue({ providerId });
-        hook = apiHooks.useCreateCreditRequest(cardId);
-      });
-      testInitCardHook(reduxKeys.useCardCreditData);
-      testInitCardHook(reduxKeys.useCardCourseRunData);
-      it('initializes username from app context', () => {
-        expect(React.useContext).toHaveBeenCalledWith(AppContext);
-      });
-      it('calls createCreditRequest api method on call', () => {
-        out = hook();
-        expect(api.createCreditRequest).toHaveBeenCalledWith({
-          providerId,
-          courseId,
-          username,
-        });
-      });
-    });
-  });
-});
diff --git a/src/hooks/index.js b/src/hooks/index.js
index 402616026..243b6120c 100644
--- a/src/hooks/index.js
+++ b/src/hooks/index.js
@@ -1,7 +1,11 @@
-import * as redux from 'data/redux/hooks';
-import * as api from './api';
 import * as utils from './utils';
+import useCourseData from './useCourseData';
+import useCourseTrackingEvent from './useCourseTrackingEvent';
+import useEntitlementInfo from './useEntitlementInfo';
+import useIsMasquerading from './useIsMasquerading';
 
-export const reduxHooks = redux;
-export const apiHooks = api;
 export const utilHooks = utils;
+export { useCourseData };
+export { useCourseTrackingEvent };
+export { useEntitlementInfo };
+export { useIsMasquerading };
diff --git a/src/hooks/useCourseData.test.tsx b/src/hooks/useCourseData.test.tsx
new file mode 100644
index 000000000..055301ae4
--- /dev/null
+++ b/src/hooks/useCourseData.test.tsx
@@ -0,0 +1,330 @@
+import { renderHook } from '@testing-library/react';
+import { useInitializeLearnerHome } from 'data/hooks';
+import { getTransformedCourseDataList } from 'utils/dataTransformers';
+import useCourseData from './useCourseData';
+
+jest.mock('data/hooks');
+jest.mock('utils/dataTransformers');
+
+const mockUseInitializeLearnerHome = useInitializeLearnerHome as jest.MockedFunction<typeof useInitializeLearnerHome>;
+const mockGetTransformedCourseDataList = getTransformedCourseDataList as
+    jest.MockedFunction<typeof getTransformedCourseDataList>;
+
+describe('useCourseData', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  const mockCourseData = [
+    {
+      cardId: 'course-1',
+      courseName: 'Introduction to React',
+      courseNumber: 'CS101',
+      enrollment: { isEnrolled: true },
+    },
+    {
+      cardId: 'course-2',
+      courseName: 'Advanced JavaScript',
+      courseNumber: 'CS201',
+      enrollment: { isEnrolled: true },
+    },
+    {
+      cardId: 'course-3',
+      courseName: 'Data Structures',
+      courseNumber: 'CS301',
+      enrollment: { isEnrolled: false },
+    },
+  ];
+
+  const mockRawCourses = [
+    { id: 1, name: 'Course 1' },
+    { id: 2, name: 'Course 2' },
+    { id: 3, name: 'Course 3' },
+  ];
+
+  describe('successful data retrieval', () => {
+    beforeEach(() => {
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: { courses: mockRawCourses },
+        isLoading: false,
+        isError: false,
+        error: null,
+      } as any);
+      mockGetTransformedCourseDataList.mockReturnValue(mockCourseData);
+    });
+
+    it('should return correct course data for existing cardId', () => {
+      const { result } = renderHook(() => useCourseData('course-1'));
+
+      expect(result.current).toEqual(mockCourseData[0]);
+      expect(mockGetTransformedCourseDataList).toHaveBeenCalledWith(mockRawCourses);
+    });
+
+    it('should return correct course data for different cardId', () => {
+      const { result } = renderHook(() => useCourseData('course-2'));
+
+      expect(result.current).toEqual(mockCourseData[1]);
+    });
+
+    it('should return correct course data for last cardId', () => {
+      const { result } = renderHook(() => useCourseData('course-3'));
+
+      expect(result.current).toEqual(mockCourseData[2]);
+    });
+
+    it('should return undefined for non-existing cardId', () => {
+      const { result } = renderHook(() => useCourseData('non-existing-course'));
+
+      expect(result.current).toBeUndefined();
+    });
+
+    it('should call getTransformedCourseDataList with correct courses data', () => {
+      renderHook(() => useCourseData('course-1'));
+
+      expect(mockGetTransformedCourseDataList).toHaveBeenCalledTimes(1);
+      expect(mockGetTransformedCourseDataList).toHaveBeenCalledWith(mockRawCourses);
+    });
+  });
+
+  describe('no data scenarios', () => {
+    it('should handle undefined data gracefully', () => {
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: undefined,
+        isLoading: false,
+        isError: false,
+        error: null,
+      } as any);
+      mockGetTransformedCourseDataList.mockReturnValue([]);
+
+      const { result } = renderHook(() => useCourseData('course-1'));
+
+      expect(result.current).toBeUndefined();
+      expect(mockGetTransformedCourseDataList).toHaveBeenCalledWith([]);
+    });
+
+    it('should handle null data gracefully', () => {
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: null,
+        isLoading: false,
+        isError: false,
+        error: null,
+      } as any);
+      mockGetTransformedCourseDataList.mockReturnValue([]);
+
+      const { result } = renderHook(() => useCourseData('course-1'));
+
+      expect(result.current).toBeUndefined();
+      expect(mockGetTransformedCourseDataList).toHaveBeenCalledWith([]);
+    });
+
+    it('should handle empty courses array', () => {
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: { courses: [] },
+        isLoading: false,
+        isError: false,
+        error: null,
+      } as any);
+      mockGetTransformedCourseDataList.mockReturnValue([]);
+
+      const { result } = renderHook(() => useCourseData('course-1'));
+
+      expect(result.current).toBeUndefined();
+      expect(mockGetTransformedCourseDataList).toHaveBeenCalledWith([]);
+    });
+
+    it('should handle missing courses property', () => {
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: {},
+        isLoading: false,
+        isError: false,
+        error: null,
+      } as any);
+      mockGetTransformedCourseDataList.mockReturnValue([]);
+
+      const { result } = renderHook(() => useCourseData('course-1'));
+
+      expect(result.current).toBeUndefined();
+      expect(mockGetTransformedCourseDataList).toHaveBeenCalledWith([]);
+    });
+  });
+
+  describe('loading and error states', () => {
+    it('should handle loading state', () => {
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: undefined,
+        isLoading: true,
+        isError: false,
+        error: null,
+      } as any);
+      mockGetTransformedCourseDataList.mockReturnValue([]);
+
+      const { result } = renderHook(() => useCourseData('course-1'));
+
+      expect(result.current).toBeUndefined();
+      expect(mockGetTransformedCourseDataList).toHaveBeenCalledWith([]);
+    });
+
+    it('should handle error state', () => {
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: undefined,
+        isLoading: false,
+        isError: true,
+        error: new Error('API Error'),
+      } as any);
+      mockGetTransformedCourseDataList.mockReturnValue([]);
+
+      const { result } = renderHook(() => useCourseData('course-1'));
+
+      expect(result.current).toBeUndefined();
+      expect(mockGetTransformedCourseDataList).toHaveBeenCalledWith([]);
+    });
+  });
+
+  describe('memoization behavior', () => {
+    beforeEach(() => {
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: { courses: mockRawCourses },
+        isLoading: false,
+        isError: false,
+        error: null,
+      } as any);
+      mockGetTransformedCourseDataList.mockReturnValue(mockCourseData);
+    });
+
+    it('should memoize result when cardId and courses data do not change', () => {
+      const { result, rerender } = renderHook(
+        ({ cardId }) => useCourseData(cardId),
+        { initialProps: { cardId: 'course-1' } },
+      );
+
+      const firstResult = result.current;
+
+      rerender({ cardId: 'course-1' });
+
+      expect(result.current).toBe(firstResult);
+      expect(mockGetTransformedCourseDataList).toHaveBeenCalledTimes(1);
+    });
+
+    it('should recalculate when cardId changes', () => {
+      const { result, rerender } = renderHook(
+        ({ cardId }) => useCourseData(cardId),
+        { initialProps: { cardId: 'course-1' } },
+      );
+
+      const firstResult = result.current;
+
+      rerender({ cardId: 'course-2' });
+
+      expect(result.current).not.toBe(firstResult);
+      expect(result.current).toEqual(mockCourseData[1]);
+    });
+
+    it('should recalculate when courses data changes', () => {
+      const { rerender } = renderHook(() => useCourseData('course-1'));
+
+      const newMockRawCourses = [...mockRawCourses, { id: 4, name: 'Course 4' }];
+      const newMockCourseData = [...mockCourseData, { cardId: 'course-4', courseName: 'New Course' }];
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: { courses: newMockRawCourses },
+        isLoading: false,
+        isError: false,
+        error: null,
+      } as any);
+      mockGetTransformedCourseDataList.mockReturnValue(newMockCourseData);
+
+      rerender();
+
+      expect(mockGetTransformedCourseDataList).toHaveBeenCalledWith(newMockRawCourses);
+    });
+  });
+
+  describe('edge cases', () => {
+    beforeEach(() => {
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: { courses: mockRawCourses },
+        isLoading: false,
+        isError: false,
+        error: null,
+      } as any);
+    });
+
+    it('should handle empty string cardId', () => {
+      mockGetTransformedCourseDataList.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseData(''));
+
+      expect(result.current).toBeUndefined();
+    });
+
+    it('should handle null cardId', () => {
+      mockGetTransformedCourseDataList.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseData(null as any));
+
+      expect(result.current).toBeUndefined();
+    });
+
+    it('should handle undefined cardId', () => {
+      mockGetTransformedCourseDataList.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseData(undefined as any));
+
+      expect(result.current).toBeUndefined();
+    });
+
+    it('should handle when getTransformedCourseDataList returns null', () => {
+      mockGetTransformedCourseDataList.mockReturnValue(null as any);
+
+      const { result } = renderHook(() => useCourseData('course-1'));
+
+      expect(result.current).toBeUndefined();
+    });
+
+    it('should handle when getTransformedCourseDataList throws error', () => {
+      mockGetTransformedCourseDataList.mockImplementation(() => {
+        throw new Error('Transformation error');
+      });
+
+      expect(() => {
+        renderHook(() => useCourseData('course-1'));
+      }).toThrow('Transformation error');
+    });
+  });
+
+  describe('integration scenarios', () => {
+    it('should work correctly with realistic course data', () => {
+      const realisticRawCourses = [
+        {
+          course_id: 'course-v1:MITx+6.00.1x+2024',
+          course_name: 'Introduction to Computer Science',
+          course_number: '6.00.1x',
+          enrollment: { is_active: true },
+        },
+      ];
+
+      const realisticTransformedCourses = [
+        {
+          cardId: 'mit-cs-intro',
+          courseName: 'Introduction to Computer Science',
+          courseNumber: '6.00.1x',
+          enrollment: { isActive: true },
+          courseId: 'course-v1:MITx+6.00.1x+2024',
+        },
+      ];
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: { courses: realisticRawCourses },
+        isLoading: false,
+        isError: false,
+        error: null,
+      } as any);
+      mockGetTransformedCourseDataList.mockReturnValue(realisticTransformedCourses);
+
+      const { result } = renderHook(() => useCourseData('mit-cs-intro'));
+
+      expect(result.current).toEqual(realisticTransformedCourses[0]);
+      expect(mockGetTransformedCourseDataList).toHaveBeenCalledWith(realisticRawCourses);
+    });
+  });
+});
diff --git a/src/hooks/useCourseData.ts b/src/hooks/useCourseData.ts
new file mode 100644
index 000000000..c9b365e64
--- /dev/null
+++ b/src/hooks/useCourseData.ts
@@ -0,0 +1,14 @@
+import { useInitializeLearnerHome } from 'data/hooks';
+import { useMemo } from 'react';
+import { getTransformedCourseDataList } from 'utils/dataTransformers';
+
+const useCourseData = (cardId: string) => {
+  const { data } = useInitializeLearnerHome();
+  const courseData = useMemo(() => {
+    const courseList = getTransformedCourseDataList(data?.courses || []);
+    return courseList?.find((c: any) => c.cardId === cardId);
+  }, [cardId, data?.courses]);
+  return courseData;
+};
+
+export default useCourseData;
diff --git a/src/hooks/useCourseTrackingEvent.test.tsx b/src/hooks/useCourseTrackingEvent.test.tsx
new file mode 100644
index 000000000..f8adb15b7
--- /dev/null
+++ b/src/hooks/useCourseTrackingEvent.test.tsx
@@ -0,0 +1,389 @@
+import { renderHook } from '@testing-library/react';
+import useCourseData from './useCourseData';
+import useCourseTrackingEvent from './useCourseTrackingEvent';
+
+jest.mock('./useCourseData');
+
+const mockUseCourseData = useCourseData as jest.MockedFunction<typeof useCourseData>;
+
+describe('useCourseTrackingEvent', () => {
+  const mockTracker = jest.fn();
+  const mockEvent = new Event('click');
+  const testCardId = 'test-card-id';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockTracker.mockImplementation(() => jest.fn());
+  });
+
+  describe('successful tracking scenarios', () => {
+    it('should call tracker with courseId when course data exists', () => {
+      const mockCourseData = {
+        courseRun: {
+          courseId: 'course-v1:TestX+CS101+2024',
+        },
+      };
+
+      mockUseCourseData.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(mockTracker, testCardId));
+
+      const trackingHandler = result.current;
+      trackingHandler(mockEvent);
+
+      expect(mockUseCourseData).toHaveBeenCalledWith(testCardId);
+      expect(mockTracker).toHaveBeenCalledWith('course-v1:TestX+CS101+2024');
+    });
+
+    it('should call tracker with courseId and additional arguments', () => {
+      const mockCourseData = {
+        courseRun: {
+          courseId: 'course-v1:TestX+CS201+2024',
+        },
+      };
+
+      const additionalArgs = ['arg1', 'arg2', { option: 'value' }];
+      mockUseCourseData.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(mockTracker, testCardId, ...additionalArgs));
+
+      const trackingHandler = result.current;
+      trackingHandler(mockEvent);
+
+      expect(mockTracker).toHaveBeenCalledWith(
+        'course-v1:TestX+CS201+2024',
+        'arg1',
+        'arg2',
+        { option: 'value' },
+      );
+    });
+
+    it('should call the returned tracking function with the event', () => {
+      const mockTrackingFunction = jest.fn();
+      mockTracker.mockReturnValue(mockTrackingFunction);
+
+      const mockCourseData = {
+        courseRun: {
+          courseId: 'course-v1:TestX+CS301+2024',
+        },
+      };
+
+      mockUseCourseData.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(mockTracker, testCardId));
+
+      const trackingHandler = result.current;
+      trackingHandler(mockEvent);
+
+      expect(mockTrackingFunction).toHaveBeenCalledWith(mockEvent);
+    });
+
+    it('should work with different event types', () => {
+      const mockTrackingFunction = jest.fn();
+      mockTracker.mockReturnValue(mockTrackingFunction);
+
+      const mockCourseData = {
+        courseRun: {
+          courseId: 'course-v1:TestX+CS401+2024',
+        },
+      };
+
+      mockUseCourseData.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(mockTracker, testCardId));
+
+      const trackingHandler = result.current;
+
+      const clickEvent = new Event('click');
+      const mouseEvent = new MouseEvent('mouseover');
+      const customEvent = new CustomEvent('custom');
+
+      trackingHandler(clickEvent);
+      trackingHandler(mouseEvent);
+      trackingHandler(customEvent);
+
+      expect(mockTrackingFunction).toHaveBeenCalledTimes(3);
+      expect(mockTrackingFunction).toHaveBeenNthCalledWith(1, clickEvent);
+      expect(mockTrackingFunction).toHaveBeenNthCalledWith(2, mouseEvent);
+      expect(mockTrackingFunction).toHaveBeenNthCalledWith(3, customEvent);
+    });
+  });
+
+  describe('no courseId scenarios', () => {
+    it('should not call tracker when courseData is null', () => {
+      mockUseCourseData.mockReturnValue(null);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(mockTracker, testCardId));
+
+      const trackingHandler = result.current;
+      trackingHandler(mockEvent);
+
+      expect(mockUseCourseData).toHaveBeenCalledWith(testCardId);
+      expect(mockTracker).not.toHaveBeenCalled();
+    });
+
+    it('should not call tracker when courseData is undefined', () => {
+      mockUseCourseData.mockReturnValue(undefined);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(mockTracker, testCardId));
+
+      const trackingHandler = result.current;
+      trackingHandler(mockEvent);
+
+      expect(mockUseCourseData).toHaveBeenCalledWith(testCardId);
+      expect(mockTracker).not.toHaveBeenCalled();
+    });
+
+    it('should not call tracker when courseRun is missing', () => {
+      const mockCourseData = {
+        courseName: 'Test Course',
+      };
+
+      mockUseCourseData.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(mockTracker, testCardId));
+
+      const trackingHandler = result.current;
+      trackingHandler(mockEvent);
+
+      expect(mockTracker).not.toHaveBeenCalled();
+    });
+
+    it('should not call tracker when courseId is missing from courseRun', () => {
+      const mockCourseData = {
+        courseRun: {
+          courseName: 'Test Course',
+        },
+      };
+
+      mockUseCourseData.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(mockTracker, testCardId));
+
+      const trackingHandler = result.current;
+      trackingHandler(mockEvent);
+
+      expect(mockTracker).not.toHaveBeenCalled();
+    });
+
+    it('should not call tracker when courseId is empty string', () => {
+      const mockCourseData = {
+        courseRun: {
+          courseId: '',
+        },
+      };
+
+      mockUseCourseData.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(mockTracker, testCardId));
+
+      const trackingHandler = result.current;
+      trackingHandler(mockEvent);
+
+      expect(mockTracker).not.toHaveBeenCalled();
+    });
+
+    it('should not call tracker when courseId is null', () => {
+      const mockCourseData = {
+        courseRun: {
+          courseId: null,
+        },
+      };
+
+      mockUseCourseData.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(mockTracker, testCardId));
+
+      const trackingHandler = result.current;
+      trackingHandler(mockEvent);
+
+      expect(mockTracker).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('cardId variations', () => {
+    it('should work with different cardId values', () => {
+      const mockCourseData = {
+        courseRun: {
+          courseId: 'course-v1:TestX+CS501+2024',
+        },
+      };
+
+      mockUseCourseData.mockReturnValue(mockCourseData);
+
+      const cardIds = ['card-1', 'card-2', 'another-card-id'];
+
+      cardIds.forEach(cardId => {
+        mockUseCourseData.mockClear();
+        mockTracker.mockClear();
+
+        const { result } = renderHook(() => useCourseTrackingEvent(mockTracker, cardId));
+
+        const trackingHandler = result.current;
+        trackingHandler(mockEvent);
+
+        expect(mockUseCourseData).toHaveBeenCalledWith(cardId);
+        expect(mockTracker).toHaveBeenCalledWith('course-v1:TestX+CS501+2024');
+      });
+    });
+
+    it('should handle empty cardId', () => {
+      mockUseCourseData.mockReturnValue(null);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(mockTracker, ''));
+
+      const trackingHandler = result.current;
+      trackingHandler(mockEvent);
+
+      expect(mockUseCourseData).toHaveBeenCalledWith('');
+      expect(mockTracker).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('hook behavior and memoization', () => {
+    it('should return a function', () => {
+      const mockCourseData = {
+        courseRun: {
+          courseId: 'course-v1:TestX+CS601+2024',
+        },
+      };
+
+      mockUseCourseData.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(mockTracker, testCardId));
+
+      expect(typeof result.current).toBe('function');
+    });
+
+    it('should create new function when dependencies change', () => {
+      const mockCourseData = {
+        courseRun: {
+          courseId: 'course-v1:TestX+CS701+2024',
+        },
+      };
+
+      mockUseCourseData.mockReturnValue(mockCourseData);
+
+      const { result, rerender } = renderHook(
+        ({ cardId, tracker }) => useCourseTrackingEvent(tracker, cardId),
+        {
+          initialProps: {
+            cardId: testCardId,
+            tracker: mockTracker,
+          },
+        },
+      );
+
+      const firstHandler = result.current;
+
+      rerender({ cardId: 'different-card-id', tracker: mockTracker });
+
+      expect(result.current).not.toBe(firstHandler);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle when tracker throws an error', () => {
+      const errorTracker = jest.fn().mockImplementation(() => {
+        throw new Error('Tracker error');
+      });
+
+      const mockCourseData = {
+        courseRun: {
+          courseId: 'course-v1:TestX+CS801+2024',
+        },
+      };
+
+      mockUseCourseData.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(errorTracker, testCardId));
+
+      const trackingHandler = result.current;
+
+      expect(() => trackingHandler(mockEvent)).toThrow('Tracker error');
+    });
+
+    it('should handle when tracker returns null', () => {
+      const nullTracker = jest.fn().mockReturnValue(null);
+
+      const mockCourseData = {
+        courseRun: {
+          courseId: 'course-v1:TestX+CS901+2024',
+        },
+      };
+
+      mockUseCourseData.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(nullTracker, testCardId));
+
+      const trackingHandler = result.current;
+
+      expect(() => trackingHandler(mockEvent)).toThrow();
+    });
+
+    it('should handle when useCourseData throws an error', () => {
+      mockUseCourseData.mockImplementation(() => {
+        throw new Error('Course data error');
+      });
+
+      expect(() => {
+        renderHook(() => useCourseTrackingEvent(mockTracker, testCardId));
+      }).toThrow('Course data error');
+    });
+  });
+
+  describe('integration scenarios', () => {
+    it('should work with realistic tracking scenario', () => {
+      const realTracker = jest.fn((courseId, action, category) => jest.fn(() => {
+        console.log(`Tracking ${action} for ${courseId} in ${category}`);
+      }));
+
+      const mockCourseData = {
+        courseRun: {
+          courseId: 'course-v1:MITx+6.00.1x+2024',
+          courseName: 'Introduction to Computer Science',
+        },
+        enrollment: {
+          isActive: true,
+        },
+      };
+
+      mockUseCourseData.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(realTracker, 'mit-cs-card', 'click', 'course-card'));
+
+      const trackingHandler = result.current;
+      trackingHandler(mockEvent);
+
+      expect(realTracker).toHaveBeenCalledWith(
+        'course-v1:MITx+6.00.1x+2024',
+        'click',
+        'course-card',
+      );
+    });
+
+    it('should work with multiple tracking calls', () => {
+      const mockTrackingFunction = jest.fn();
+      mockTracker.mockReturnValue(mockTrackingFunction);
+
+      const mockCourseData = {
+        courseRun: {
+          courseId: 'course-v1:TestX+CS1001+2024',
+        },
+      };
+
+      mockUseCourseData.mockReturnValue(mockCourseData);
+
+      const { result } = renderHook(() => useCourseTrackingEvent(mockTracker, testCardId));
+
+      const trackingHandler = result.current;
+
+      trackingHandler(mockEvent);
+      trackingHandler(mockEvent);
+      trackingHandler(mockEvent);
+
+      expect(mockTracker).toHaveBeenCalledTimes(3);
+      expect(mockTrackingFunction).toHaveBeenCalledTimes(3);
+    });
+  });
+});
diff --git a/src/hooks/useCourseTrackingEvent.ts b/src/hooks/useCourseTrackingEvent.ts
new file mode 100644
index 000000000..13b1cd589
--- /dev/null
+++ b/src/hooks/useCourseTrackingEvent.ts
@@ -0,0 +1,14 @@
+import useCourseData from './useCourseData';
+
+const useCourseTrackingEvent = (tracker: Function, cardId: string, ...args: any[]) => {
+  const courseData = useCourseData(cardId);
+  const courseId = (courseData as any)?.courseRun?.courseId;
+
+  return (e: Event) => {
+    if (courseId) {
+      tracker(courseId, ...args)(e);
+    }
+  };
+};
+
+export default useCourseTrackingEvent;
diff --git a/src/hooks/useEntitlementInfo.test.tsx b/src/hooks/useEntitlementInfo.test.tsx
new file mode 100644
index 000000000..02587ac51
--- /dev/null
+++ b/src/hooks/useEntitlementInfo.test.tsx
@@ -0,0 +1,534 @@
+import { renderHook } from '@testing-library/react';
+import useEntitlementInfo from './useEntitlementInfo';
+
+describe('useEntitlementInfo', () => {
+  const today = new Date();
+  const pastDate = new Date(today.getTime() - 30 * 24 * 60 * 60 * 1000); // 30 days ago
+  const futureDate = new Date(today.getTime() + 30 * 24 * 60 * 60 * 1000); // 30 days from now
+  const farFutureDate = new Date(today.getTime() + 200 * 24 * 60 * 60 * 1000); // 200 days from now
+
+  const mockAvailableSessions = [
+    {
+      sessionId: 'session-1',
+      courseName: 'Session 1',
+      startDate: '2024-03-01',
+    },
+    {
+      sessionId: 'session-2',
+      courseName: 'Session 2',
+      startDate: '2024-06-01',
+    },
+  ];
+
+  describe('non-entitlement scenarios', () => {
+    it('should return isEntitlement: false when entitlement is null', () => {
+      const courseData = {
+        entitlement: null,
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current).toEqual({
+        isEntitlement: false,
+      });
+    });
+
+    it('should return isEntitlement: false when entitlement is undefined', () => {
+      const courseData = {
+        entitlement: undefined,
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current).toEqual({
+        isEntitlement: false,
+      });
+    });
+
+    it('should return isEntitlement: false when entitlement is empty object', () => {
+      const courseData = {
+        entitlement: {},
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current).toEqual({
+        isEntitlement: false,
+      });
+    });
+
+    it('should return isEntitlement: false when entitlement.isEntitlement is false', () => {
+      const courseData = {
+        entitlement: {
+          isEntitlement: false,
+          uuid: 'test-uuid',
+          changeDeadline: futureDate.toISOString(),
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current).toEqual({
+        isEntitlement: false,
+      });
+    });
+
+    it('should return isEntitlement: false when courseData is null', () => {
+      const { result } = renderHook(() => useEntitlementInfo(null));
+
+      expect(result.current).toEqual({
+        isEntitlement: false,
+      });
+    });
+
+    it('should return isEntitlement: false when courseData is undefined', () => {
+      const { result } = renderHook(() => useEntitlementInfo(undefined));
+
+      expect(result.current).toEqual({
+        isEntitlement: false,
+      });
+    });
+  });
+
+  describe('valid entitlement scenarios', () => {
+    const baseEntitlementData = {
+      entitlement: {
+        isEntitlement: true,
+        uuid: 'test-uuid-123',
+        changeDeadline: futureDate.toISOString(),
+        isExpired: false,
+        isFulfilled: false,
+        availableSessions: mockAvailableSessions,
+      },
+    };
+
+    it('should return complete entitlement info for valid entitlement', () => {
+      const { result } = renderHook(() => useEntitlementInfo(baseEntitlementData));
+
+      expect(result.current).toMatchObject({
+        isEntitlement: true,
+        availableSessions: mockAvailableSessions,
+        changeDeadline: expect.any(Date),
+        isExpired: false,
+        isFulfilled: false,
+        uuid: 'test-uuid-123',
+        hasSessions: true,
+        canChange: true,
+        showExpirationWarning: true,
+      });
+    });
+
+    it('should correctly parse changeDeadline as Date object', () => {
+      const { result } = renderHook(() => useEntitlementInfo(baseEntitlementData));
+
+      expect(result.current.changeDeadline).toBeInstanceOf(Date);
+      expect(result.current.changeDeadline?.getTime()).toBe(futureDate.getTime());
+    });
+
+    it('should return hasSessions: true when availableSessions has items', () => {
+      const { result } = renderHook(() => useEntitlementInfo(baseEntitlementData));
+
+      expect(result.current.hasSessions).toBe(true);
+    });
+
+    it('should return hasSessions: false when availableSessions is empty', () => {
+      const courseData = {
+        entitlement: {
+          ...baseEntitlementData.entitlement,
+          availableSessions: [],
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.hasSessions).toBe(false);
+    });
+
+    it('should return hasSessions: false when availableSessions is null', () => {
+      const courseData = {
+        entitlement: {
+          ...baseEntitlementData.entitlement,
+          availableSessions: null,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.hasSessions).toBe(false);
+    });
+
+    it('should return hasSessions: false when availableSessions is undefined', () => {
+      const courseData = {
+        entitlement: {
+          ...baseEntitlementData.entitlement,
+          availableSessions: undefined,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.hasSessions).toBe(false);
+    });
+  });
+
+  describe('deadline and expiration logic', () => {
+    it('should return canChange: false when deadline has passed', () => {
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          changeDeadline: pastDate.toISOString(),
+          isExpired: false,
+          isFulfilled: false,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.canChange).toBe(false);
+    });
+
+    it('should return canChange: true when deadline has not passed', () => {
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          changeDeadline: futureDate.toISOString(),
+          isExpired: false,
+          isFulfilled: false,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.canChange).toBe(true);
+    });
+
+    it('should return showExpirationWarning: false when already fulfilled', () => {
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          changeDeadline: futureDate.toISOString(),
+          isExpired: false,
+          isFulfilled: true,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.showExpirationWarning).toBe(false);
+    });
+
+    it('should return showExpirationWarning: false when deadline has passed', () => {
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          changeDeadline: pastDate.toISOString(),
+          isExpired: false,
+          isFulfilled: false,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.showExpirationWarning).toBe(false);
+    });
+
+    it('should return showExpirationWarning: false when deadline is more than 6 months away', () => {
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          changeDeadline: farFutureDate.toISOString(),
+          isExpired: false,
+          isFulfilled: false,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.showExpirationWarning).toBe(false);
+    });
+
+    it('should return showExpirationWarning: true when conditions are met', () => {
+      const withinSixMonths = new Date(today.getTime() + 90 * 24 * 60 * 60 * 1000); // 90 days from now
+
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          changeDeadline: withinSixMonths.toISOString(),
+          isExpired: false,
+          isFulfilled: false,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.showExpirationWarning).toBe(true);
+    });
+  });
+
+  describe('entitlement properties passthrough', () => {
+    it('should pass through isExpired property', () => {
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          changeDeadline: futureDate.toISOString(),
+          isExpired: true,
+          isFulfilled: false,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.isExpired).toBe(true);
+    });
+
+    it('should pass through isFulfilled property', () => {
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          changeDeadline: futureDate.toISOString(),
+          isExpired: false,
+          isFulfilled: true,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.isFulfilled).toBe(true);
+    });
+
+    it('should pass through uuid property', () => {
+      const testUuid = 'unique-entitlement-uuid-456';
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: testUuid,
+          changeDeadline: futureDate.toISOString(),
+          isExpired: false,
+          isFulfilled: false,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.uuid).toBe(testUuid);
+    });
+
+    it('should pass through availableSessions property', () => {
+      const customSessions = [
+        { sessionId: 'custom-1', courseName: 'Custom Session' },
+      ];
+
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          changeDeadline: futureDate.toISOString(),
+          isExpired: false,
+          isFulfilled: false,
+          availableSessions: customSessions,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.availableSessions).toEqual(customSessions);
+    });
+  });
+
+  describe('memoization behavior', () => {
+    it('should memoize result when courseData does not change', () => {
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          changeDeadline: futureDate.toISOString(),
+          isExpired: false,
+          isFulfilled: false,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const { result, rerender } = renderHook(
+        ({ data }) => useEntitlementInfo(data),
+        { initialProps: { data: courseData } },
+      );
+
+      const firstResult = result.current;
+
+      rerender({ data: courseData });
+
+      expect(result.current).toBe(firstResult);
+    });
+
+    it('should recalculate when courseData changes', () => {
+      const courseData1 = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid-1',
+          changeDeadline: futureDate.toISOString(),
+          isExpired: false,
+          isFulfilled: false,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const courseData2 = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid-2',
+          changeDeadline: futureDate.toISOString(),
+          isExpired: false,
+          isFulfilled: true,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const { result, rerender } = renderHook(
+        ({ data }) => useEntitlementInfo(data),
+        { initialProps: { data: courseData1 } },
+      );
+
+      const firstResult = result.current;
+
+      rerender({ data: courseData2 });
+
+      expect(result.current).not.toBe(firstResult);
+      expect(result.current.uuid).toBe('test-uuid-2');
+      expect(result.current.isFulfilled).toBe(true);
+    });
+  });
+
+  describe('edge cases and error handling', () => {
+    it('should handle invalid date strings gracefully', () => {
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          changeDeadline: 'invalid-date-string',
+          isExpired: false,
+          isFulfilled: false,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.changeDeadline).toBeInstanceOf(Date);
+    });
+
+    it('should handle missing changeDeadline property', () => {
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          isExpired: false,
+          isFulfilled: false,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.changeDeadline).toBeInstanceOf(Date);
+    });
+
+    it('should handle entitlement with missing optional properties', () => {
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          changeDeadline: futureDate.toISOString(),
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.isEntitlement).toBe(true);
+      expect(result.current.uuid).toBe('test-uuid');
+      expect(result.current.isExpired).toBeUndefined();
+      expect(result.current.isFulfilled).toBeUndefined();
+      expect(result.current.availableSessions).toBeUndefined();
+      expect(result.current.hasSessions).toBe(false);
+    });
+
+    it('should handle courseData with extra properties', () => {
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          changeDeadline: futureDate.toISOString(),
+          isExpired: false,
+          isFulfilled: false,
+          availableSessions: mockAvailableSessions,
+        },
+        course: {
+          courseName: 'Extra Course Info',
+        },
+        enrollment: {
+          isActive: true,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.isEntitlement).toBe(true);
+      expect(result.current.uuid).toBe('test-uuid');
+    });
+  });
+
+  describe('boundary date calculations', () => {
+    it('should correctly calculate 6-month boundary for showExpirationWarning', () => {
+      const exactly180Days = new Date();
+      exactly180Days.setDate(exactly180Days.getDate() + 180);
+
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          changeDeadline: exactly180Days.toISOString(),
+          isExpired: false,
+          isFulfilled: false,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+
+      expect(result.current.showExpirationWarning).toBe(true);
+    });
+
+    it('should handle date exactly at deadline boundary', () => {
+      const courseData = {
+        entitlement: {
+          isEntitlement: true,
+          uuid: 'test-uuid',
+          changeDeadline: new Date().toISOString(),
+          isExpired: false,
+          isFulfilled: false,
+          availableSessions: mockAvailableSessions,
+        },
+      };
+
+      const { result } = renderHook(() => useEntitlementInfo(courseData));
+      expect(typeof result.current.canChange).toBe('boolean');
+      expect(typeof result.current.showExpirationWarning).toBe('boolean');
+    });
+  });
+});
diff --git a/src/hooks/useEntitlementInfo.ts b/src/hooks/useEntitlementInfo.ts
new file mode 100644
index 000000000..2461ee4eb
--- /dev/null
+++ b/src/hooks/useEntitlementInfo.ts
@@ -0,0 +1,33 @@
+import { useMemo } from 'react';
+
+const useEntitlementInfo = (courseData) => useMemo(() => {
+  const { entitlement } = courseData || {};
+  if (!entitlement || Object.keys(entitlement).length === 0 || entitlement.isEntitlement === false) {
+    return { isEntitlement: false };
+  }
+  const today = new Date();
+  const dateSixMonthsFromNow = new Date();
+  dateSixMonthsFromNow.setDate(dateSixMonthsFromNow.getDate() + 180);
+  const deadline = new Date(entitlement.changeDeadline);
+  const deadlinePassed = deadline < today;
+  const showExpirationWarning = (
+    !entitlement.isFulfilled
+        && !deadlinePassed
+        && deadline <= dateSixMonthsFromNow
+  );
+  return {
+    isEntitlement: true,
+
+    availableSessions: entitlement.availableSessions,
+    changeDeadline: deadline,
+    isExpired: entitlement.isExpired,
+    isFulfilled: entitlement.isFulfilled,
+    uuid: entitlement.uuid,
+
+    hasSessions: entitlement.availableSessions?.length > 0,
+    canChange: !deadlinePassed,
+    showExpirationWarning,
+  };
+}, [courseData]);
+
+export default useEntitlementInfo;
diff --git a/src/hooks/useIsMasquerading.test.tsx b/src/hooks/useIsMasquerading.test.tsx
new file mode 100644
index 000000000..be15ab4a2
--- /dev/null
+++ b/src/hooks/useIsMasquerading.test.tsx
@@ -0,0 +1,450 @@
+import { renderHook } from '@testing-library/react';
+import { useMasquerade } from 'data/context';
+import { useInitializeLearnerHome } from 'data/hooks';
+import { useIsMasquerading } from 'hooks';
+
+jest.mock('data/context/MasqueradeProvider');
+jest.mock('data/hooks');
+
+const mockUseMasquerade = useMasquerade as jest.MockedFunction<typeof useMasquerade>;
+const mockUseInitializeLearnerHome = useInitializeLearnerHome as jest.MockedFunction<typeof useInitializeLearnerHome>;
+
+describe('useIsMasquerading', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('returns true when masquerading successfully', () => {
+    it('should return true when masqueradeUser exists and no error', () => {
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: 'test-user',
+        setMasqueradeUser: jest.fn(),
+      });
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: {},
+        isError: false,
+        isLoading: false,
+        error: null,
+      } as any);
+
+      const { result } = renderHook(() => useIsMasquerading());
+
+      expect(result.current).toBe(true);
+    });
+
+    it('should return true when masqueradeUser is a non-empty string and no error', () => {
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: 'admin@example.com',
+        setMasqueradeUser: jest.fn(),
+      });
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: {},
+        isError: false,
+        isLoading: false,
+        error: null,
+      } as any);
+
+      const { result } = renderHook(() => useIsMasquerading());
+
+      expect(result.current).toBe(true);
+    });
+
+    it('should return true when masqueradeUser is valid and query is loading', () => {
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: 'test-user',
+        setMasqueradeUser: jest.fn(),
+      });
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: undefined,
+        isError: false,
+        isLoading: true,
+        error: null,
+      } as any);
+
+      const { result } = renderHook(() => useIsMasquerading());
+
+      expect(result.current).toBe(true);
+    });
+
+    it('should return true when masqueradeUser is valid and query is successful', () => {
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: 'student123',
+        setMasqueradeUser: jest.fn(),
+      });
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: { courses: [] },
+        isError: false,
+        isLoading: false,
+        error: null,
+      } as any);
+
+      const { result } = renderHook(() => useIsMasquerading());
+
+      expect(result.current).toBe(true);
+    });
+  });
+
+  describe('returns false when no masqueradeUser', () => {
+    it('should return false when masqueradeUser is null', () => {
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: undefined,
+        setMasqueradeUser: jest.fn(),
+      });
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: {},
+        isError: false,
+        isLoading: false,
+        error: null,
+      } as any);
+
+      const { result } = renderHook(() => useIsMasquerading());
+
+      expect(result.current).toBe(false);
+    });
+
+    it('should return false when masqueradeUser is undefined', () => {
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: undefined,
+        setMasqueradeUser: jest.fn(),
+      });
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: {},
+        isError: false,
+        isLoading: false,
+        error: null,
+      } as any);
+
+      const { result } = renderHook(() => useIsMasquerading());
+
+      expect(result.current).toBe(false);
+    });
+
+    it('should return false when masqueradeUser is empty string', () => {
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: '',
+        setMasqueradeUser: jest.fn(),
+      });
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: {},
+        isError: false,
+        isLoading: false,
+        error: null,
+      } as any);
+
+      const { result } = renderHook(() => useIsMasquerading());
+
+      expect(result.current).toBe(false);
+    });
+
+    it('should return false when masqueradeUser is whitespace only', () => {
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: '   ',
+        setMasqueradeUser: jest.fn(),
+      });
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: {},
+        isError: false,
+        isLoading: false,
+        error: null,
+      } as any);
+
+      const { result } = renderHook(() => useIsMasquerading());
+
+      expect(result.current).toBe(true);
+    });
+  });
+
+  describe('returns false when there is an error', () => {
+    it('should return false when masqueradeUser exists but query has error', () => {
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: 'test-user',
+        setMasqueradeUser: jest.fn(),
+      });
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: undefined,
+        isError: true,
+        isLoading: false,
+        error: new Error('API Error'),
+      } as any);
+
+      const { result } = renderHook(() => useIsMasquerading());
+
+      expect(result.current).toBe(false);
+    });
+
+    it('should return false when masqueradeUser is valid but query fails with network error', () => {
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: 'admin@example.com',
+        setMasqueradeUser: jest.fn(),
+      });
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: undefined,
+        isError: true,
+        isLoading: false,
+        error: new Error('Network Error'),
+      } as any);
+
+      const { result } = renderHook(() => useIsMasquerading());
+
+      expect(result.current).toBe(false);
+    });
+
+    it('should return false when masqueradeUser is valid but query fails with 404 error', () => {
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: 'nonexistent-user',
+        setMasqueradeUser: jest.fn(),
+      });
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: undefined,
+        isError: true,
+        isLoading: false,
+        error: { response: { status: 404 } },
+      } as any);
+
+      const { result } = renderHook(() => useIsMasquerading());
+
+      expect(result.current).toBe(false);
+    });
+  });
+
+  describe('returns false for edge cases', () => {
+    it('should return false when both masqueradeUser is undefined and there is an error', () => {
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: undefined,
+        setMasqueradeUser: jest.fn(),
+      });
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: undefined,
+        isError: true,
+        isLoading: false,
+        error: new Error('API Error'),
+      } as any);
+
+      const { result } = renderHook(() => useIsMasquerading());
+
+      expect(result.current).toBe(false);
+    });
+
+    it('should return false when masqueradeUser is empty string and there is an error', () => {
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: '',
+        setMasqueradeUser: jest.fn(),
+      });
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: undefined,
+        isError: true,
+        isLoading: false,
+        error: new Error('API Error'),
+      } as any);
+
+      const { result } = renderHook(() => useIsMasquerading());
+
+      expect(result.current).toBe(false);
+    });
+
+    it('should return false when masqueradeUser is undefined and there is an error', () => {
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: undefined,
+        setMasqueradeUser: jest.fn(),
+      });
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: undefined,
+        isError: true,
+        isLoading: false,
+        error: new Error('API Error'),
+      } as any);
+
+      const { result } = renderHook(() => useIsMasquerading());
+
+      expect(result.current).toBe(false);
+    });
+  });
+
+  describe('hook behavior and reactivity', () => {
+    it('should update when masqueradeUser changes', () => {
+      const { result, rerender } = renderHook(() => useIsMasquerading());
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: undefined,
+        setMasqueradeUser: jest.fn(),
+      });
+
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: {},
+        isError: false,
+        isLoading: false,
+        error: null,
+      } as any);
+
+      rerender();
+      expect(result.current).toBe(false);
+
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: 'test-user',
+        setMasqueradeUser: jest.fn(),
+      });
+
+      rerender();
+      expect(result.current).toBe(true);
+    });
+
+    it('should update when error state changes', () => {
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: 'test-user',
+        setMasqueradeUser: jest.fn(),
+      });
+
+      const { result, rerender } = renderHook(() => useIsMasquerading());
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: {},
+        isError: false,
+        isLoading: false,
+        error: null,
+      } as any);
+
+      rerender();
+      expect(result.current).toBe(true);
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: undefined,
+        isError: true,
+        isLoading: false,
+        error: new Error('API Error'),
+      } as any);
+
+      rerender();
+      expect(result.current).toBe(false);
+    });
+
+    it('should return boolean type consistently', () => {
+      const testCases = [
+        { masqueradeUser: 'user', isError: false, expected: true },
+        { masqueradeUser: undefined, isError: false, expected: false },
+        { masqueradeUser: 'user', isError: true, expected: false },
+        { masqueradeUser: '', isError: false, expected: false },
+      ];
+
+      testCases.forEach(({ masqueradeUser, isError, expected }) => {
+        mockUseMasquerade.mockReturnValue({
+          masqueradeUser,
+          setMasqueradeUser: jest.fn(),
+        });
+
+        mockUseInitializeLearnerHome.mockReturnValue({
+          data: isError ? undefined : {},
+          isError,
+          isLoading: false,
+          error: isError ? new Error('Test error') : null,
+        } as any);
+
+        const { result } = renderHook(() => useIsMasquerading());
+
+        expect(typeof result.current).toBe('boolean');
+        expect(result.current).toBe(expected);
+      });
+    });
+  });
+
+  describe('integration scenarios', () => {
+    it('should work correctly in typical masquerading flow', () => {
+      const { result, rerender } = renderHook(() => useIsMasquerading());
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: undefined,
+        setMasqueradeUser: jest.fn(),
+      });
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: {},
+        isError: false,
+        isLoading: false,
+        error: null,
+      } as any);
+
+      rerender();
+      expect(result.current).toBe(false);
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: 'student123',
+        setMasqueradeUser: jest.fn(),
+      });
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: undefined,
+        isError: false,
+        isLoading: true,
+        error: null,
+      } as any);
+
+      rerender();
+      expect(result.current).toBe(true);
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: { courses: ['course1', 'course2'] },
+        isError: false,
+        isLoading: false,
+        error: null,
+      } as any);
+
+      rerender();
+      expect(result.current).toBe(true);
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: undefined,
+        isError: true,
+        isLoading: false,
+        error: new Error('User not found'),
+      } as any);
+
+      rerender();
+      expect(result.current).toBe(false);
+      mockUseMasquerade.mockReturnValue({
+        masqueradeUser: undefined,
+        setMasqueradeUser: jest.fn(),
+      });
+      mockUseInitializeLearnerHome.mockReturnValue({
+        data: {},
+        isError: false,
+        isLoading: false,
+        error: null,
+      } as any);
+
+      rerender();
+      expect(result.current).toBe(false);
+    });
+
+    it('should handle various masqueradeUser formats', () => {
+      const userFormats = [
+        'username',
+        'user@example.com',
+        'user.name@domain.co.uk',
+        'user_123',
+        'User Name',
+        '12345',
+      ];
+
+      userFormats.forEach(user => {
+        mockUseMasquerade.mockReturnValue({
+          masqueradeUser: user,
+          setMasqueradeUser: jest.fn(),
+        });
+
+        mockUseInitializeLearnerHome.mockReturnValue({
+          data: {},
+          isError: false,
+          isLoading: false,
+          error: null,
+        } as any);
+
+        const { result } = renderHook(() => useIsMasquerading());
+        expect(result.current).toBe(true);
+      });
+    });
+  });
+});
diff --git a/src/hooks/useIsMasquerading.ts b/src/hooks/useIsMasquerading.ts
new file mode 100644
index 000000000..19c6d3bc9
--- /dev/null
+++ b/src/hooks/useIsMasquerading.ts
@@ -0,0 +1,10 @@
+import { useMasquerade } from 'data/context';
+import { useInitializeLearnerHome } from 'data/hooks';
+
+const useIsMasquerading = () => {
+  const { masqueradeUser } = useMasquerade();
+  const { isError } = useInitializeLearnerHome();
+  return !!masqueradeUser && !isError;
+};
+
+export default useIsMasquerading;
diff --git a/src/index.jsx b/src/index.jsx
index 49e5858ac..957aa912e 100755
--- a/src/index.jsx
+++ b/src/index.jsx
@@ -13,7 +13,6 @@ import {
   ErrorPage,
   PageWrap,
 } from '@edx/frontend-platform/react';
-import store from 'data/store';
 import {
   APP_READY,
   APP_INIT_ERROR,
@@ -22,22 +21,36 @@ import {
   mergeConfig,
 } from '@edx/frontend-platform';
 
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import ContextProviders from 'data/context';
 import { configuration } from './config';
 
 import messages from './i18n';
 
 import App from './App';
 
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 60 * 60_000,
+    },
+  },
+});
+
 subscribe(APP_READY, () => {
   const root = createRoot(document.getElementById('root'));
 
   root.render(
     <StrictMode>
-      <AppProvider store={store}>
-        <Routes>
-          <Route path="/" element={<PageWrap><App /></PageWrap>} />
-          <Route path="*" element={<Navigate to="/" replace />} />
-        </Routes>
+      <AppProvider>
+        <ContextProviders>
+          <QueryClientProvider client={queryClient}>
+            <Routes>
+              <Route path="/" element={<PageWrap><App /></PageWrap>} />
+              <Route path="*" element={<Navigate to="/" replace />} />
+            </Routes>
+          </QueryClientProvider>
+        </ContextProviders>
       </AppProvider>
     </StrictMode>,
   );
diff --git a/src/index.test.jsx b/src/index.test.jsx
index ba53223f8..0b826e3b7 100644
--- a/src/index.test.jsx
+++ b/src/index.test.jsx
@@ -33,7 +33,6 @@ jest.mock('@edx/frontend-platform', () => ({
   subscribe: jest.fn(),
 }));
 
-jest.mock('data/store', () => ({ redux: 'store' }));
 jest.mock('./App', () => 'App');
 
 describe('app registry', () => {
diff --git a/src/plugin-slots/WidgetSidebarSlot/index.test.jsx b/src/plugin-slots/WidgetSidebarSlot/index.test.jsx
index a5b852daa..1a8c50ba8 100644
--- a/src/plugin-slots/WidgetSidebarSlot/index.test.jsx
+++ b/src/plugin-slots/WidgetSidebarSlot/index.test.jsx
@@ -1,20 +1,18 @@
 import { render, screen } from '@testing-library/react';
 
 import { IntlProvider } from '@edx/frontend-platform/i18n';
-import { reduxHooks } from 'hooks';
+import { useInitializeLearnerHome } from 'data/hooks';
 import WidgetSidebarSlot from '.';
 
-jest.mock('hooks', () => ({
-  reduxHooks: {
-    usePlatformSettingsData: jest.fn(),
-  },
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: jest.fn(),
 }));
 
 const courseSearchUrl = 'mock-url';
 
 describe('WidgetSidebar', () => {
   it('renders PluginSlot with correct children', () => {
-    reduxHooks.usePlatformSettingsData.mockReturnValueOnce({ courseSearchUrl });
+    useInitializeLearnerHome.mockReturnValueOnce({ platformSettings: { courseSearchUrl } });
     render(<IntlProvider locale="en"><WidgetSidebarSlot /></IntlProvider>);
     const pluginSlot = screen.getByText('Looking for a new challenge?');
     expect(pluginSlot).toBeDefined();
diff --git a/src/plugins/LookingForChallengeWidget/index.jsx b/src/plugins/LookingForChallengeWidget/index.jsx
index 9410c99af..047a5e073 100644
--- a/src/plugins/LookingForChallengeWidget/index.jsx
+++ b/src/plugins/LookingForChallengeWidget/index.jsx
@@ -4,7 +4,7 @@ import { useIntl } from '@edx/frontend-platform/i18n';
 import { Card, Hyperlink, Icon } from '@openedx/paragon';
 import { ArrowForward } from '@openedx/paragon/icons';
 
-import { reduxHooks } from 'hooks';
+import { useInitializeLearnerHome } from 'data/hooks';
 import moreCoursesSVG from 'assets/more-courses-sidewidget.svg';
 import { baseAppUrl } from 'data/services/lms/urls';
 
@@ -16,7 +16,8 @@ export const arrowIcon = (<Icon className="mx-1" src={ArrowForward} />);
 
 export const LookingForChallengeWidget = () => {
   const { formatMessage } = useIntl();
-  const { courseSearchUrl } = reduxHooks.usePlatformSettingsData();
+  const { data: learnerData } = useInitializeLearnerHome();
+  const courseSearchUrl = learnerData?.platformSettings?.courseSearchUrl || '';
   const hyperlinkDestination = baseAppUrl(courseSearchUrl) || '';
 
   return (
diff --git a/src/plugins/LookingForChallengeWidget/index.test.jsx b/src/plugins/LookingForChallengeWidget/index.test.jsx
index cd1e46bce..70e8c2734 100644
--- a/src/plugins/LookingForChallengeWidget/index.test.jsx
+++ b/src/plugins/LookingForChallengeWidget/index.test.jsx
@@ -5,12 +5,14 @@ import messages from './messages';
 
 const courseSearchUrl = 'http://localhost:18000/course-search-url';
 
-jest.mock('hooks', () => ({
-  reduxHooks: {
-    usePlatformSettingsData: () => ({
-      courseSearchUrl,
-    }),
-  },
+jest.mock('data/hooks', () => ({
+  useInitializeLearnerHome: () => ({
+    data: {
+      platformSettings: {
+        courseSearchUrl,
+      },
+    },
+  }),
 }));
 
 jest.mock('./track', () => ({
diff --git a/src/setupTest.jsx b/src/setupTest.jsx
index 259e57aa3..4defb728d 100755
--- a/src/setupTest.jsx
+++ b/src/setupTest.jsx
@@ -1,21 +1,2 @@
 /* eslint-disable import/no-extraneous-dependencies */
 import '@testing-library/jest-dom';
-
-jest.mock('reselect', () => ({
-  createSelector: jest.fn((preSelectors, cb) => ({ preSelectors, cb })),
-}));
-
-// Mock react-redux hooks
-// unmock for integration tests
-jest.mock('react-redux', () => {
-  const dispatch = jest.fn((...args) => ({ dispatch: args })).mockName('react-redux.dispatch');
-  return {
-    connect: (mapStateToProps, mapDispatchToProps) => (component) => ({
-      mapStateToProps,
-      mapDispatchToProps,
-      component,
-    }),
-    useDispatch: jest.fn(() => dispatch),
-    useSelector: jest.fn((selector) => ({ useSelector: selector })),
-  };
-});
diff --git a/src/test/app.test.jsx b/src/test/app.test.jsx
deleted file mode 100644
index cf39efd1d..000000000
--- a/src/test/app.test.jsx
+++ /dev/null
@@ -1,279 +0,0 @@
-/* eslint-disable */
-import React from 'react';
-import * as redux from 'redux';
-import { Provider } from 'react-redux';
-import {
-  act,
-  render,
-  waitFor,
-  within,
-  prettyDOM,
-} from '@testing-library/react';
-import {
-  initialize,
-  mergeConfig,
-} from '@edx/frontend-platform';
-
-import { useIntl, IntlProvider } from '@edx/frontend-platform/i18n';
-
-import { useFormatDate } from 'utils/hooks';
-
-import api from 'data/services/lms/api';
-import * as fakeData from 'data/services/lms/fakeData/courses';
-import { RequestKeys, RequestStates } from 'data/constants/requests';
-import reducers from 'data/redux';
-import { selectors } from 'data/redux';
-import { apiHooks } from 'hooks';
-import { cardId as genCardId } from 'data/redux/app/reducer';
-
-import messages from 'i18n';
-
-import App from 'App';
-import Inspector from './inspector';
-import appMessages from './messages';
-
-jest.unmock('@edx/frontend-component-footer');
-
-jest.unmock('react-redux');
-jest.unmock('reselect');
-jest.unmock('hooks');
-
-jest.mock('plugin-slots/WidgetSidebarSlot', () => jest.fn(() => 'widget-sidebar'));
-
-jest.mock('@edx/frontend-platform', () => ({
-  ...jest.requireActual('@edx/frontend-platform'),
-  getConfig: () => jest.requireActual('../config').configuration,
-}));
-
-jest.mock('@edx/frontend-platform/analytics', () => ({
-  sendTrackEvent: jest.fn(),
-}));
-
-jest.mock('@edx/frontend-platform/auth', () => ({
-  getAuthenticatedHttpClient: jest.fn(),
-  getLoginRedirectUrl: jest.fn(),
-}));
-
-jest.mock('@edx/frontend-enterprise-hotjar', () => ({
-  initializeHotjar: jest.fn(),
-}));
-
-jest.mock('@edx/frontend-platform/i18n', () => ({
-  ...jest.requireActual('@edx/frontend-platform/i18n'),
-  useIntl: () => ({
-    formatMessage: jest.requireActual('testUtils').formatMessage,
-    formatDate: (date) => `Date-${date}`,
-  }),
-}));
-
-jest.mock('@edx/frontend-platform/logging', () => ({
-  logError: jest.fn(),
-}));
-
-jest.mock('utils/hooks', () => {
-  const formatDate = jest.fn(date => `Date-${date}`);
-  return {
-    formatDate,
-    useFormatDate: () => formatDate,
-  };
-});
-
-
-const configureStore = () => redux.createStore(
-  reducers,
-);
-
-let el;
-let store;
-let state;
-let retryLink;
-let inspector;
-
-/**
- * Simple wrapper for updating the top-level state variable, that also returns the new value
- * @return {obj} - current redux store state
- */
-const getState = () => {
-  state = store.getState();
-  return state;
-};
-
-/**
- * Object to be filled with resolve/reject functions for all controlled network comm channels
- */
-const resolveFns = {
-};
-/**
- * Mock the api with jest functions that can be tested against.
- */
-const mockNetworkError = (reject) => () => reject(new Error({
-  response: { status: ErrorStatuses.badRequest },
-}));
-
-const mockForbiddenError = (reject) => () => reject(new Error({
-  response: { status: ErrorStatuses.forbidden },
-}));
-
-
-const allCourses = [
-  ...fakeData.courseRunData,
-  ...fakeData.entitlementData,
-];
-
-const { compileCourseRunData, compileEntitlementData } = fakeData;
-
-const initCourses = jest.fn(() => []);
-
-let initializeApp;
-
-const mockApi = () => {
-  api.initializeList = jest.fn(() => new Promise(
-    (resolve, reject) => {
-      resolveFns.init = {
-        success: () => {
-          const data = {
-            courses: initCourses(),
-            ...fakeData.globalData,
-          };
-          resolve({ data });
-        },
-      };
-    }));
-};
-
-/**
- * load and configure the store, render the element, and populate the top-level state object
- */
-const renderEl = async () => {
-  store = configureStore();
-  el = await render(
-    <IntlProvider locale='en' messages={messages.en}>
-      <Provider store={store}>
-        <App />
-      </Provider>
-    </IntlProvider>,
-  );
-  getState();
-};
-
-const waitForEqual = async (valFn, expected, key) => waitFor(() => {
-  expect(valFn(), `${key} is expected to equal ${expected}`).toEqual(expected);
-});
-const waitForRequestStatus = (key, status) => waitForEqual(
-  () => getState().requests[key].status,
-  status,
-  key,
-);
-
-const loadApp = async (courses) => {
-  initCourses.mockReturnValue(courses.map(compileCourseRunData));
-  await renderEl();
-  inspector = new Inspector(el);
-  await waitForRequestStatus(RequestKeys.initialize, RequestStates.pending);
-  resolveFns.init.success();
-  await waitForRequestStatus(RequestKeys.initialize, RequestStates.completed);
-}
-
-const courseNames = [
-  'course-name-1',
-  'course-name-2',
-  'course-name-3',
-];
-
-describe('ESG app integration tests', () => {
-  beforeEach(() => {
-    mockApi();
-  });
-
-  test('initialization', async () => {
-    await loadApp([{ courseName: courseNames[0] }]);
-  });
-
-  describe('course cards', () => {
-    const courseNames = [
-      'course-name-0',
-      'course-name-1',
-      'course-name-2',
-    ];
-    const testCourse = async (index, tests) => {
-      await getState();
-      const cards = inspector.get.courseCards;
-      const card = cards.at(index);
-      const cardId = genCardId(index);
-      const cardDetails = inspector.get.card.details(card);
-      const courseData = selectors.app.courseCard.course(state, cardId);
-      const { courseName } = selectors.app.courseCard.course(state, cardId);
-      inspector.verifyText(inspector.get.card.header(card), courseName);
-      if (tests.length > index) {
-        tests[index]({ cardId, cardDetails });
-      }
-    }
-
-    const loadCourse = async (course) => {
-      await loadApp([course].map(compileCourseRunData));
-      await waitForRequestStatus(RequestKeys.initialize, RequestStates.pending);
-      resolveFns.init.success();
-      await waitForRequestStatus(RequestKeys.initialize, RequestStates.completed);
-    };
-
-    describe('audit courses', () => {
-      test('audit', async () => {
-        const courses = [
-          { courseName: courseNames[0] }, // audit, course run not started
-          {
-            courseName: courseNames[1],
-            enrollment: {
-              coursewareAccess: {
-                isTooEarly: true,
-                hasUnmetPrerequisites: false,
-                isStaff: false,
-              },
-            },
-          }, // audit, course run not started, is too early
-          {
-            courseName: courseNames[2],
-            courseRun: {
-              courseRun: { isStarted: true },
-            },
-            enrollment: {
-              accessExpirationDate: fakeData.pastDate,
-              canUpgrade: false,
-              isAuditAccessExpired: true,
-              hasStarted: true,
-            },
-          }, // audit, course run and learner started, access expired, cannot upgrade
-        ];
-        const formatDate = useFormatDate();
-        await loadApp(courses);
-        await testCourse(0, [
-          ({ cardId, cardDetails }) => {
-            const enrollment = selectors.app.courseCard.enrollment(state, cardId);
-            const courseRun = selectors.app.courseCard.courseRun(state, cardId);
-            const courseProvider = selectors.app.courseCard.courseProvider(state, cardId);
-            const course = selectors.app.courseCard.course(state, cardId);
-            expect(enrollment.isAudit).toEqual(true);
-            expect(courseRun.isStarted).toEqual(false);
-            expect(enrollment.canUpgrade).toEqual(true);
-            [
-              courseProvider.name,
-              course.courseNumber,
-              appMessages.withValues.CourseCardDetails.courseStarts({
-                startDate: formatDate(new Date(courseRun.startDate)),
-              }),
-            ].forEach(value => inspector.verifyTextIncludes(cardDetails, value));
-          },
-        ]);
-        await testCourse(1, [
-          ({ cardId, cardDetails }) => {
-            const enrollment = selectors.app.courseCard.enrollment(state, cardId);
-            const courseRun = selectors.app.courseCard.courseRun(state, cardId);
-            expect(enrollment.isAudit).toEqual(true);
-            expect(courseRun.isStarted).toEqual(false);
-            expect(enrollment.coursewareAccess.isTooEarly).toEqual(true);
-            expect(enrollment.hasAccess).toEqual(false);
-          },
-        ]);
-      });
-    });
-  });
-});
diff --git a/src/test/inspector.js b/src/test/inspector.js
deleted file mode 100644
index c04bf5e5b..000000000
--- a/src/test/inspector.js
+++ /dev/null
@@ -1,50 +0,0 @@
-/* eslint-disable import/no-extraneous-dependencies */
-import { within } from '@testing-library/react';
-
-// import fakeData from 'data/services/lms/fakeData';
-// import { gradingStatusTransform } from 'data/redux/grading/selectors/selected';
-
-// import appMessages from './messages';
-
-/**
- * App inspector class providing methods to return elements from within
- * the virtual DOM
- * @props {Root Node} el - Root app render node.
- */
-class Inspector {
-  constructor(el) {
-    this.el = el;
-    this.getByRole = this.el.getByRole;
-    this.getByText = this.el.getByText;
-    this.getByLabelText = this.el.getByLabelText;
-    this.findByText = this.el.findByText;
-    this.findByLabelText = this.el.findByLabelText;
-  }
-
-  get get() {
-    return {
-      courseCards: this.el.getAllByTestId('CourseCard'),
-      card: {
-        header: (card) => within(card).getByTestId('CourseCardTitle'),
-        details: (card) => within(card).getByTestId('CourseCardDetails'),
-        // banners: (card) => within(card).getByTestId('CourseCardBanners'),
-        // programsBadge: (card) => within(card).getByTestId('RelatedProgramsBadge'),
-        // actions: (card) => within(card).getByTestId('CourseCardActions'),
-      },
-    };
-  }
-
-  /**
-   * Returns promises for attempting to find elements within the DOM
-   */
-  get find() {
-    return {
-    };
-  }
-
-  verifyText = (el, text) => within(el).getByText(text);
-
-  verifyTextIncludes = (el, text) => within(el).getByText(text, { exact: false });
-}
-
-export default Inspector;
diff --git a/src/test/messages.js b/src/test/messages.js
deleted file mode 100644
index 16bf61c8e..000000000
--- a/src/test/messages.js
+++ /dev/null
@@ -1,29 +0,0 @@
-import CourseCardDetails from 'containers/CourseCard/components/CourseCardDetails/messages';
-
-const mapMessages = (messages) => Object.keys(messages).reduce(
-  (acc, key) => ({ ...acc, [key]: messages[key].defaultMessage }),
-  {},
-);
-
-const mapMessagesWithValues = (messages) => Object.keys(messages).reduce(
-  (acc, key) => ({
-    ...acc,
-    [key]: (values) => {
-      let message = messages[key].defaultMessage;
-      if (values) {
-        Object.keys(values).forEach(valueKey => {
-          message = message.replaceAll(`{${valueKey}}`, values[valueKey]);
-        });
-      }
-      return message;
-    },
-  }),
-  {},
-);
-
-export default {
-  CourseCardDetails: mapMessages(CourseCardDetails),
-  withValues: {
-    CourseCardDetails: mapMessagesWithValues(CourseCardDetails),
-  },
-};
diff --git a/src/test/utils.js b/src/test/utils.js
deleted file mode 100644
index 7eba5e312..000000000
--- a/src/test/utils.js
+++ /dev/null
@@ -1,3 +0,0 @@
-export const mockSuccess = (returnValFn) => (...args) => Promise.resolve(returnValFn(...args));
-
-export const mockFailure = (returnValFn) => (...args) => Promise.reject(returnValFn(...args));
diff --git a/src/tracking/trackers/socialShare.js b/src/tracking/trackers/socialShare.js
index b4bae2af0..808709e32 100644
--- a/src/tracking/trackers/socialShare.js
+++ b/src/tracking/trackers/socialShare.js
@@ -1,4 +1,4 @@
-import api from 'data/services/lms/api';
+import { logShare } from 'data/services/lms/api';
 
 /**
  * Track Social Share event click.
@@ -6,6 +6,6 @@ import api from 'data/services/lms/api';
  * @param {string} site - sharing destination ('facebook', 'twitter')
  * @return {func} - Callback that tracks the event when fired.
  */
-export const shareClicked = (courseId, site) => () => api.logShare({ courseId, site });
+export const shareClicked = (courseId, site) => () => logShare({ courseId, site });
 
 export default shareClicked;
diff --git a/src/utils/StrictDict.js b/src/utils/StrictDict.js
index a127e48a7..750e68039 100644
--- a/src/utils/StrictDict.js
+++ b/src/utils/StrictDict.js
@@ -12,7 +12,6 @@ const strictGet = (target, name) => {
     return target[name];
   }
 
-  console.log(name.toString());
   console.error({ target, name });
   const e = Error(`invalid property "${name.toString()}"`);
   console.error(e.stack);
diff --git a/src/utils/dataTransformers.test.ts b/src/utils/dataTransformers.test.ts
new file mode 100644
index 000000000..24a6bb4ed
--- /dev/null
+++ b/src/utils/dataTransformers.test.ts
@@ -0,0 +1,626 @@
+import { FilterKeys, SortKeys, ListPageSize } from 'data/constants/app';
+import {
+  getVisibleList,
+  getTransformedCourseDataList,
+  getTransformedCourseDataObject,
+} from './dataTransformers';
+
+const mockGet = jest.fn();
+
+Object.defineProperty(window, 'location', {
+  value: {
+    search: '',
+  },
+  writable: true,
+});
+
+// Mock URLSearchParams constructor
+global.URLSearchParams = jest.fn().mockImplementation(() => ({
+  get: mockGet,
+}));
+
+type VisibleListResult = {
+  visibleList: Array<{
+    course: { courseName: string };
+    enrollment: { lastEnrolled: Date }
+  }>;
+  numPages: number;
+};
+
+describe('dataTransformers', () => {
+  const mockCourses = [
+    {
+      course: {
+        courseName: 'Introduction to React',
+        courseNumber: 'CS101',
+      },
+      enrollment: {
+        isEnrolled: true,
+        isVerified: false,
+        hasStarted: true,
+        lastEnrolled: '2024-01-15T00:00:00Z',
+      },
+      courseRun: {
+        isArchived: false,
+      },
+    },
+    {
+      course: {
+        courseName: 'Advanced JavaScript',
+        courseNumber: 'CS201',
+      },
+      enrollment: {
+        isEnrolled: true,
+        isVerified: true,
+        hasStarted: false,
+        lastEnrolled: '2024-02-01T00:00:00Z',
+      },
+      courseRun: {
+        isArchived: false,
+      },
+    },
+    {
+      course: {
+        courseName: 'Data Structures',
+        courseNumber: 'CS301',
+      },
+      enrollment: {
+        isEnrolled: false,
+        isVerified: false,
+        hasStarted: false,
+        lastEnrolled: null,
+      },
+      courseRun: null,
+    },
+    {
+      course: {
+        courseName: 'Algorithms',
+        courseNumber: 'CS401',
+      },
+      enrollment: {
+        isEnrolled: true,
+        isVerified: false,
+        hasStarted: true,
+        lastEnrolled: '2024-01-01T00:00:00Z',
+      },
+      courseRun: {
+        isArchived: true,
+      },
+    },
+  ];
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockGet.mockReturnValue(null);
+    window.location.search = '';
+  });
+
+  describe('getTransformedCourseDataObject', () => {
+    it('should transform courses array into object with cardId keys', () => {
+      const result = getTransformedCourseDataObject(mockCourses);
+
+      expect(Object.keys(result)).toEqual(['card-0', 'card-1', 'card-2', 'card-3']);
+      expect(result['card-0']).toMatchObject({
+        ...mockCourses[0],
+        cardId: 'card-0',
+      });
+      expect(result['card-1']).toMatchObject({
+        ...mockCourses[1],
+        cardId: 'card-1',
+      });
+    });
+
+    it('should add current timestamp to lastEnrolled when null', () => {
+      const coursesWithNullEnrollment = [
+        {
+          course: { courseName: 'Test Course' },
+          enrollment: {
+            lastEnrolled: null,
+            isEnrolled: true,
+          },
+        },
+      ];
+
+      const result = getTransformedCourseDataObject(coursesWithNullEnrollment);
+      const transformedCourse = result['card-0'];
+
+      expect(transformedCourse.enrollment.lastEnrolled).toBeGreaterThan(0);
+      expect(typeof transformedCourse.enrollment.lastEnrolled).toBe('number');
+    });
+
+    it('should preserve existing lastEnrolled timestamp', () => {
+      const existingTimestamp = '2024-01-15T00:00:00Z';
+      const coursesWithTimestamp = [
+        {
+          enrollment: {
+            lastEnrolled: existingTimestamp,
+          },
+        },
+      ];
+
+      const result = getTransformedCourseDataObject(coursesWithTimestamp);
+
+      expect(result['card-0'].enrollment.lastEnrolled).toBe(existingTimestamp);
+    });
+
+    it('should handle empty courses array', () => {
+      const result = getTransformedCourseDataObject([]);
+
+      expect(result).toEqual({});
+      expect(Object.keys(result)).toHaveLength(0);
+    });
+
+    it('should handle courses without enrollment property', () => {
+      const coursesWithoutEnrollment = [
+        {
+          course: { courseName: 'Test Course' },
+        },
+      ];
+
+      const result = getTransformedCourseDataObject(coursesWithoutEnrollment);
+
+      expect(result['card-0']).toMatchObject({
+        course: { courseName: 'Test Course' },
+        cardId: 'card-0',
+      });
+    });
+
+    it('should generate sequential cardId for multiple courses', () => {
+      const manyCourses = Array.from({ length: 5 }, (_, i) => ({
+        course: { courseName: `Course ${i}` },
+      }));
+
+      const result = getTransformedCourseDataObject(manyCourses);
+
+      expect(Object.keys(result)).toEqual([
+        'card-0', 'card-1', 'card-2', 'card-3', 'card-4',
+      ]);
+    });
+  });
+
+  describe('getTransformedCourseDataList', () => {
+    it('should transform courses array into array with cardId properties', () => {
+      const result = getTransformedCourseDataList(mockCourses);
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result).toHaveLength(4);
+      expect(result[0]).toMatchObject({
+        ...mockCourses[0],
+        cardId: 'card-0',
+      });
+      expect(result[1]).toMatchObject({
+        ...mockCourses[1],
+        cardId: 'card-1',
+      });
+    });
+
+    it('should return empty array for empty input', () => {
+      const result = getTransformedCourseDataList([]);
+
+      expect(result).toEqual([]);
+    });
+
+    it('should maintain course order', () => {
+        type MockCourseType = {
+          course: { courseName: string };
+        };
+        const result = getTransformedCourseDataList(mockCourses) as MockCourseType[];
+
+        expect(result[0].course.courseName).toBe('Introduction to React');
+        expect(result[1].course.courseName).toBe('Advanced JavaScript');
+        expect(result[2].course.courseName).toBe('Data Structures');
+        expect(result[3].course.courseName).toBe('Algorithms');
+    });
+  });
+
+  describe('getVisibleList', () => {
+    const transformedCourses = [
+      {
+        course: { courseName: 'Introduction to React' },
+        enrollment: {
+          isEnrolled: true,
+          isVerified: false,
+          hasStarted: true,
+          lastEnrolled: new Date('2024-01-15'),
+        },
+        courseRun: { isArchived: false },
+      },
+      {
+        course: { courseName: 'Advanced JavaScript' },
+        enrollment: {
+          isEnrolled: true,
+          isVerified: true,
+          hasStarted: false,
+          lastEnrolled: new Date('2024-02-01'),
+        },
+        courseRun: { isArchived: false },
+      },
+      {
+        course: { courseName: 'Data Structures' },
+        enrollment: {
+          isEnrolled: false,
+          isVerified: false,
+          hasStarted: false,
+          lastEnrolled: new Date('2024-01-10'),
+        },
+        courseRun: null,
+      },
+      {
+        course: { courseName: 'Algorithms' },
+        enrollment: {
+          isEnrolled: true,
+          isVerified: false,
+          hasStarted: true,
+          lastEnrolled: new Date('2024-01-01'),
+        },
+        courseRun: { isArchived: true },
+      },
+    ];
+
+    describe('filtering', () => {
+      it('should filter courses by notEnrolled', () => {
+        const result = getVisibleList(
+          transformedCourses,
+          [FilterKeys.notEnrolled],
+          SortKeys.title,
+          1,
+        ) as VisibleListResult;
+
+        expect(result.visibleList).toHaveLength(1);
+        expect(result.visibleList[0].course.courseName).toBe('Data Structures');
+      });
+
+      it('should filter courses by done (archived)', () => {
+        const result = getVisibleList(
+          transformedCourses,
+          [FilterKeys.done],
+          SortKeys.title,
+          1,
+        ) as VisibleListResult;
+
+        expect(result.visibleList).toHaveLength(1);
+        expect(result.visibleList[0].course.courseName).toBe('Algorithms');
+      });
+
+      it('should filter courses by upgraded (verified)', () => {
+        const result = getVisibleList(
+          transformedCourses,
+          [FilterKeys.upgraded],
+          SortKeys.title,
+          1,
+        ) as VisibleListResult;
+
+        expect(result.visibleList).toHaveLength(1);
+        expect(result.visibleList[0].course.courseName).toBe('Advanced JavaScript');
+      });
+
+      it('should filter courses by inProgress (hasStarted)', () => {
+        const result = getVisibleList(
+          transformedCourses,
+          [FilterKeys.inProgress],
+          SortKeys.title,
+          1,
+        ) as VisibleListResult;
+
+        expect(result.visibleList).toHaveLength(2);
+        const courseNames = result.visibleList.map(c => c.course.courseName).sort();
+        expect(courseNames).toEqual(['Algorithms', 'Introduction to React']);
+      });
+
+      it('should filter courses by notStarted', () => {
+        const result = getVisibleList(
+          transformedCourses,
+          [FilterKeys.notStarted],
+          SortKeys.title,
+          1,
+        ) as VisibleListResult;
+
+        expect(result.visibleList).toHaveLength(2);
+        const courseNames = result.visibleList.map(c => c.course.courseName).sort();
+        expect(courseNames).toEqual(['Advanced JavaScript', 'Data Structures']);
+      });
+
+      it('should apply multiple filters with AND logic', () => {
+        const result = getVisibleList(
+          transformedCourses,
+          [FilterKeys.upgraded, FilterKeys.notStarted],
+          SortKeys.title,
+          1,
+        ) as VisibleListResult;
+
+        expect(result.visibleList).toHaveLength(1);
+        expect(result.visibleList[0].course.courseName).toBe('Advanced JavaScript');
+      });
+
+      it('should return all courses when no filters applied', () => {
+        const result = getVisibleList(
+          transformedCourses,
+          [],
+          SortKeys.title,
+          1,
+        );
+
+        expect(result.visibleList).toHaveLength(4);
+      });
+
+      it('should return empty list when filters match no courses', () => {
+        const result = getVisibleList(
+          transformedCourses,
+          [FilterKeys.notEnrolled, FilterKeys.upgraded],
+          SortKeys.title,
+          1,
+        );
+
+        expect(result.visibleList).toHaveLength(0);
+      });
+    });
+
+    describe('sorting', () => {
+      it('should sort by title (alphabetically)', () => {
+        const result = getVisibleList(
+          transformedCourses,
+          [],
+          SortKeys.title,
+          1,
+        ) as VisibleListResult;
+
+        const sortedNames = result.visibleList.map(c => c.course.courseName);
+        expect(sortedNames).toEqual([
+          'Advanced JavaScript',
+          'Algorithms',
+          'Data Structures',
+          'Introduction to React',
+        ]);
+      });
+
+      it('should sort by enrolled date (newest first - reverse order)', () => {
+        const result = getVisibleList(
+          transformedCourses,
+          [],
+          SortKeys.enrolled,
+          1,
+        ) as VisibleListResult;
+
+        const enrolledDates = result.visibleList.map(c => c.enrollment.lastEnrolled);
+        expect(enrolledDates[0]).toEqual(new Date('2024-02-01'));
+        expect(enrolledDates[1]).toEqual(new Date('2024-01-15'));
+        expect(enrolledDates[2]).toEqual(new Date('2024-01-10'));
+        expect(enrolledDates[3]).toEqual(new Date('2024-01-01'));
+      });
+
+      it('should handle courses with identical sort values', () => {
+        const identicalCourses = [
+          {
+            course: { courseName: 'Same Name' },
+            enrollment: { lastEnrolled: new Date('2024-01-01') },
+          },
+          {
+            course: { courseName: 'Same Name' },
+            enrollment: { lastEnrolled: new Date('2024-01-01') },
+          },
+        ];
+
+        const result = getVisibleList(
+          identicalCourses,
+          [],
+          SortKeys.title,
+          1,
+        );
+
+        expect(result.visibleList).toHaveLength(2);
+      });
+    });
+
+    describe('pagination', () => {
+      const manyCourses = Array.from({ length: 25 }, (_, i) => ({
+        course: { courseName: `Course ${i.toString().padStart(2, '0')}` },
+        enrollment: {
+          isEnrolled: true,
+          hasStarted: false,
+          lastEnrolled: new Date(`2024-01-${(i + 1).toString().padStart(2, '0')}`),
+        },
+        courseRun: { isArchived: false },
+      }));
+
+      it('should paginate results correctly for first page', () => {
+        const result = getVisibleList(
+          manyCourses,
+          [],
+          SortKeys.title,
+          1,
+        ) as VisibleListResult;
+
+        expect(result.visibleList).toHaveLength(ListPageSize);
+        expect(result.numPages).toBe(Math.ceil(25 / ListPageSize));
+        expect(result.visibleList[0].course.courseName).toBe('Course 00');
+      });
+
+      it('should paginate results correctly for second page', () => {
+        const listSize = 50;
+        const manyCoursesList = Array.from({ length: listSize }, (_, i) => ({
+          course: { courseName: `Course ${i.toString().padStart(2, '0')}` },
+        }));
+        const result = getVisibleList(
+          manyCoursesList,
+          [],
+          SortKeys.title,
+          2,
+        ) as VisibleListResult;
+        expect(result.visibleList).toHaveLength(listSize - ListPageSize);
+        const expectedFirstCourse = `Course ${ListPageSize.toString().padStart(2, '0')}`;
+        expect(result.visibleList[0].course.courseName).toBe(expectedFirstCourse);
+      });
+
+      it('should handle last page with fewer items', () => {
+        const result = getVisibleList(
+          manyCourses,
+          [],
+          SortKeys.title,
+          Math.ceil(25 / ListPageSize),
+        );
+
+        expect(result.visibleList).toHaveLength(25 % ListPageSize || ListPageSize);
+      });
+
+      it('should calculate correct number of pages', () => {
+        const result = getVisibleList(
+          manyCourses,
+          [],
+          SortKeys.title,
+          1,
+        );
+
+        expect(result.numPages).toBe(Math.ceil(25 / ListPageSize));
+      });
+
+      it('should disable pagination when query parameter is set', () => {
+        mockGet.mockReturnValue('1');
+
+        const result = getVisibleList(
+          manyCourses,
+          [],
+          SortKeys.title,
+          1,
+        );
+
+        expect(result.visibleList).toHaveLength(25);
+        expect(result.numPages).toBe(1);
+      });
+
+      it('should use pagination when disable_pagination is not 1', () => {
+        mockGet.mockReturnValue('0');
+
+        const result = getVisibleList(
+          manyCourses,
+          [],
+          SortKeys.title,
+          1,
+        );
+
+        expect(result.visibleList).toHaveLength(ListPageSize);
+      });
+
+      it('should handle empty courses array with pagination', () => {
+        const result = getVisibleList(
+          [],
+          [],
+          SortKeys.title,
+          1,
+        );
+
+        expect(result.visibleList).toHaveLength(0);
+        expect(result.numPages).toBe(0);
+      });
+    });
+
+    describe('edge cases', () => {
+      it('should handle courses with missing properties', () => {
+        const coursesWithMissingProps = [
+          {
+            course: { courseName: 'Course 1' },
+            enrollment: {}, // Missing properties
+            courseRun: null,
+          },
+        ];
+
+        expect(() => {
+          getVisibleList(
+            coursesWithMissingProps,
+            [FilterKeys.inProgress],
+            SortKeys.title,
+            1,
+          );
+        }).not.toThrow();
+      });
+
+      it('should handle invalid page number', () => {
+        const result = getVisibleList(
+          transformedCourses,
+          [],
+          SortKeys.title,
+          0,
+        );
+
+        // Should handle gracefully, possibly returning empty or adjusting
+        expect(result.visibleList).toBeDefined();
+      });
+
+      it('should handle very large page number', () => {
+        const result = getVisibleList(
+          transformedCourses,
+          [],
+          SortKeys.title,
+          999,
+        );
+
+        expect(result.visibleList).toHaveLength(0);
+      });
+
+      it('should handle null courseRun in done filter', () => {
+        const coursesWithNullCourseRun = [
+          {
+            course: { courseName: 'Test Course' },
+            enrollment: { isEnrolled: true },
+            courseRun: null,
+          },
+        ];
+
+        const result = getVisibleList(
+          coursesWithNullCourseRun,
+          [FilterKeys.done],
+          SortKeys.title,
+          1,
+        );
+
+        expect(result.visibleList).toHaveLength(0);
+      });
+    });
+
+    describe('integration scenarios', () => {
+      it('should handle complex filtering, sorting, and pagination together', () => {
+        const result = getVisibleList(
+          transformedCourses,
+          [FilterKeys.inProgress],
+          SortKeys.enrolled,
+          1,
+        ) as VisibleListResult;
+
+        // Should get in-progress courses, sorted by enrollment date (newest first)
+        expect(result.visibleList).toHaveLength(2);
+        expect(result.visibleList[0].course.courseName).toBe('Introduction to React');
+        expect(result.visibleList[1].course.courseName).toBe('Algorithms');
+      });
+
+      it('should maintain functionality with realistic course data structure', () => {
+        const realisticCourses = [
+          {
+            course: {
+              courseName: 'Introduction to Computer Science',
+              courseNumber: 'CS50',
+            },
+            enrollment: {
+              isEnrolled: true,
+              isVerified: true,
+              hasStarted: true,
+              lastEnrolled: new Date('2024-01-15'),
+            },
+            courseRun: {
+              isArchived: false,
+              startDate: '2024-02-01',
+            },
+          },
+        ];
+
+        const result = getVisibleList(
+          realisticCourses,
+          [],
+          SortKeys.title,
+          1,
+        ) as VisibleListResult;
+
+        expect(result.visibleList).toHaveLength(1);
+        expect(result.visibleList[0].course.courseName).toBe('Introduction to Computer Science');
+      });
+    });
+  });
+});
diff --git a/src/utils/dataTransformers.ts b/src/utils/dataTransformers.ts
new file mode 100644
index 000000000..ac5bd7d9e
--- /dev/null
+++ b/src/utils/dataTransformers.ts
@@ -0,0 +1,67 @@
+import { FilterKeys, ListPageSize, SortKeys } from 'data/constants/app';
+import StrictDict from './StrictDict';
+
+const cardId = (val) => `card-${val}`;
+const today = Date.now();
+
+const transformCourseData = (courses) => courses.reduce(
+  (obj, curr, index) => {
+    const out = { ...curr, cardId: cardId(index) };
+    if (out.enrollment?.lastEnrolled === null) {
+      out.enrollment.lastEnrolled = today;
+    }
+    return { ...obj, [cardId(index)]: out };
+  },
+  {},
+);
+
+const getTransformedCourseDataObject = (courses) => transformCourseData(courses);
+
+const getTransformedCourseDataList = (courses) => Object.values(transformCourseData(courses));
+
+const getVisibleList = (courses: any[], filters: string[], sortBy: string, pageNumber: number) => {
+  const courseFilters = StrictDict({
+    [FilterKeys.notEnrolled]: (course) => !course.enrollment.isEnrolled,
+    [FilterKeys.done]: (course) => course.courseRun !== null && course.courseRun.isArchived,
+    [FilterKeys.upgraded]: (course) => course.enrollment.isVerified,
+    [FilterKeys.inProgress]: (course) => course.enrollment.hasStarted,
+    [FilterKeys.notStarted]: (course) => !course.enrollment.hasStarted,
+  });
+
+  const transforms = StrictDict({
+    [SortKeys.enrolled]: ({ enrollment }) => new Date(enrollment?.lastEnrolled),
+    [SortKeys.title]: ({ course }) => course.courseName.toLowerCase(),
+  });
+
+  const courseFilterFn = filtersList => (filtersList.length
+    ? course => filtersList.reduce((match, filter) => match && courseFilters[filter](course), true)
+    : () => true);
+
+  const sortFn = (transform, { reverse }) => (v1, v2) => {
+    const [a, b] = [v1, v2].map(transform);
+    if (a === b) { return 0; }
+    return (((a as any) > (b as any)) ? 1 : -1) * (reverse ? -1 : 1);
+  };
+
+  const list = courses
+    .filter(courseFilterFn(filters))
+    .sort(sortFn(transforms[sortBy], { reverse: sortBy === SortKeys.enrolled }));
+
+  const querySearch = new URLSearchParams(window.location.search);
+  const disablePagination = querySearch.get('disable_pagination');
+  const pageSize = Number(disablePagination) === 1 ? 0 : ListPageSize;
+
+  if (pageSize === 0) {
+    return {
+      visibleList: list,
+      numPages: 1,
+    };
+  }
+  const result = {
+    visibleList: list.slice((pageNumber - 1) * pageSize, pageNumber * pageSize),
+    numPages: Math.ceil(list.length / pageSize),
+  };
+  return result;
+};
+
+export { getVisibleList, getTransformedCourseDataList, getTransformedCourseDataObject };