diff --git a/src/layouts/welcome-page/welcome-page.spec.js b/src/layouts/welcome-page/welcome-page.spec.js
index 573b8fce..29520d8c 100644
--- a/src/layouts/welcome-page/welcome-page.spec.js
+++ b/src/layouts/welcome-page/welcome-page.spec.js
@@ -179,13 +179,8 @@ describe('navigation', () => {
     test('if duplicates found, navigate to duplicate check page', async () => {
         // Arrange
         const { wrapper } = getMountedComponent({});
-
-        const duplicatesExist = {
-            policyLookupResponse: {},
-            duplicateCheckResponse: [{ test: 'a'}]
-        };
-
-        settleAllPromises.mockImplementation(() => Promise.resolve(duplicatesExist));
+        useMainStore().getDuplicateReferrals = jest.fn().mockImplementation(() => Promise.resolve({}));
+        useMainStore().applicationUser.duplicateOrders = [{ test: 'a' }];
 
         // Act
         await wrapper.vm.forwardButtonAction();
@@ -199,39 +194,18 @@ describe('navigation', () => {
             { [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
         );
     });
-    test('if policy and vehicles are found, navigate to policy-vehicle page', async () => {
+    test('if policy and vehicles are found but no duplicates, navigate to policy-vehicle page', async () => {
         // Arrange
-        const mockvehicles = [
-            {
-                vin: 'TEST_VIN'
-            },
-            {
-                vin: 'TEST_VIN2'
-            }
+        const { wrapper } = setupMocks({});
+        useMainStore().getDuplicateReferrals = jest.fn().mockImplementation(() => Promise.resolve({}));
+
+        useMainStore().applicationUser.duplicateOrders = [];
+        useMainStore().order.policy.policyLookupSuccessful = true;
+        useMainStore().order.policy.vehicles = [
+            { vin: 'TEST_VIN' },
+            { vin: 'TEST_VIN2' }
         ];
 
-        const { wrapper } = setupMocks({
-            policies: [{
-                vehicles: [
-                    {
-                        vin: 'TEST_VIN'
-                    },
-                    {
-                        vin: 'TEST_VIN2'
-                    }
-                ]
-            }]
-        });
-
-        await wrapper.setData({
-            vehiclesFound: mockvehicles
-        });
-
-        useMainStore().issConfig.isCoverageEnabled = true;
-        useMainStore().order.policy.policyNumber = 'p_0001';
-        useMainStore().order.policy.dateOfLoss = '2022-01-28';
-        useMainStore().order.accountNumber = '00000';
-
         // Act
         await wrapper.vm.forwardButtonAction();
 
@@ -243,20 +217,14 @@ describe('navigation', () => {
             { [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
         );
     });
-    test('if policy is found, but no vehicles, navigate to vehicle-selection page', async () => {
+    test('if policy is found, but no vehicles and no duplicates, navigate to vehicle-selection page', async () => {
         // Arrange
-        const { wrapper } = setupMocks({
-            policies: [{}]
-        });
+        const { wrapper } = setupMocks({});
+        useMainStore().getDuplicateReferrals = jest.fn().mockImplementation(() => Promise.resolve({}));
 
-        await wrapper.setData({
-            vehiclesFound: null
-        });
-
-        useMainStore().issConfig.isCoverageEnabled = true;
-        useMainStore().order.policy.policyNumber = 'p_0001';
-        useMainStore().order.policy.dateOfLoss = '2022-01-28';
-        useMainStore().order.accountNumber = '00000';
+        useMainStore().applicationUser.duplicateOrders = [];
+        useMainStore().order.policy.policyLookupSuccessful = true;
+        useMainStore().order.policy.vehicles = [];
 
         // Act
 
@@ -270,16 +238,34 @@ describe('navigation', () => {
             { [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
         );
     });
-    test('if policy is not found, navigate to policy-holder-details page', async () => {
+    test('if policy is found, but null vehicles and no duplicates, navigate to vehicle-selection page', async () => {
         // Arrange
-        const { wrapper } = setupMocks({
-            policies: null
-        });
+        const { wrapper } = setupMocks({});
+        useMainStore().getDuplicateReferrals = jest.fn().mockImplementation(() => Promise.resolve({}));
 
-        useMainStore().issConfig.isCoverageEnabled = true;
-        useMainStore().order.policy.policyNumber = 'p_0001';
-        useMainStore().order.policy.dateOfLoss = '2022-01-28';
-        useMainStore().order.accountNumber = '00000';
+        useMainStore().applicationUser.duplicateOrders = [];
+        useMainStore().order.policy.policyLookupSuccessful = true;
+        useMainStore().order.policy.vehicles = null;
+
+        // Act
+
+        await wrapper.vm.forwardButtonAction();
+
+        // Assert
+        expect(wrapper.vm.$router.navigate).toHaveBeenCalledWith(
+            navigationScenarios.CLICKED_FORWARD_POLICY_VERIFIED_NO_VEHICLES,
+            undefined,
+            {},
+            { [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
+        );
+    });
+    test('if policy is not found and no duplicates, navigate to policy-holder-details page', async () => {
+        // Arrange
+        const { wrapper } = setupMocks({});
+        useMainStore().getDuplicateReferrals = jest.fn().mockImplementation(() => Promise.resolve({}));
+
+        useMainStore().order.policy.policyLookupSuccessful = false;
+        useMainStore().applicationUser.duplicateOrders = [];
 
         // Act
         await wrapper.vm.navigateForward();
diff --git a/src/layouts/welcome-page/welcome-page.vue b/src/layouts/welcome-page/welcome-page.vue
index d2ad05b0..c4d49845 100644
--- a/src/layouts/welcome-page/welcome-page.vue
+++ b/src/layouts/welcome-page/welcome-page.vue
@@ -167,6 +167,7 @@
 
 <script>
 // Components
+import { Form, defineRule } from 'vee-validate';
 import siteHeader from '@/iss-components/site-header/site-header.vue';
 import siteSubHeader from '@/iss-components/site-sub-header/site-sub-header.vue';
 import siteFooter from '@/iss-components/site-footer/site-footer.vue';
@@ -178,7 +179,6 @@ import textBlock from '@/digital-components/text-block/text-block.vue';
 // Supporting files
 import { fetchCmsContentForPage } from '@/helpers/cms-content-helper';
 import settleAllPromises from '@/helpers/layout-helper';
-import { Form, defineRule } from 'vee-validate';
 import { required, regex } from '@/helpers/validation-rules';
 import errorMessages from '@/constants/error-messages';
 import BaseFormMixin from '@/mixins/base-form-mixin.js';
@@ -243,7 +243,6 @@ export default {
     data() {
         return {
             welcomePageModel: this.getWelcomePageModelFromStore(),
-            vehiclesFound: [],
             duplicates: [],
             rules: {
                 policyNumber: 'policy-number-required',
@@ -298,76 +297,27 @@ export default {
     },
     methods: {
         async forwardButtonAction() {
-            this.mainStore.updatePolicyData(this.welcomePageModel);
-            const duplicateCheckResponse = await useMainStore().getDuplicateReferrals();
-            const duplicatePromiseResultMap = [
-                {
-                    resultKey: 'duplicateCheckResponse',
-                    promise: duplicateCheckResponse
-                }
-            ];
-            const duplicateResultMap = await settleAllPromises(duplicatePromiseResultMap);
-
-            this.mainStore.applicationUser.duplicateOrders = duplicateResultMap.duplicateCheckResponse ?? [];
-            this.duplicates = duplicateResultMap.duplicateCheckResponse;
-
-            // call coverage policy lookup if isCoverageEnabled flag enabled
-            if (this.isCoverageEnabled) {
-                const policyLookupResponse = useMainStore().getCoveragePolicyInfo({
-                    accountNumber: this.mainStore.order.accountNumber.toString(),
-                    policyNumber: this.mainStore.order.policy.policyNumber,
-                    dateOfLoss: this.mainStore.order.policy.dateOfLoss,
-                    zipCode: this.mainStore.order.policy.policyZipCode
-                });
-
-                const policyPromiseResultMap = [
-                    {
-                        resultKey: 'policyLookupResponse',
-                        promise: policyLookupResponse
+            useMainStore().updatePolicyData(this.welcomePageModel);
+            await useMainStore().getDuplicateReferrals()
+                .finally(async () => {
+                    if (this.isCoverageEnabled) {
+                        await useMainStore().getCoveragePolicyInfo();
                     }
-                ];
-
-                const policyResultMap = await settleAllPromises(policyPromiseResultMap);
-                const policyInfo = policyResultMap.policyLookupResponse;
-
-                // if policy lookup fails, navigate directly to policy-holder-details page
-                if (!policyInfo) {
                     this.navigateForward();
-                }
-
-                const policy = policyInfo.policies?.[0];
-                if (policy) {
-                    // populate policy holder details from policy lookup
-                    this.mainStore.order.customer.address.streetAddress = policy.insureds?.[0]?.address;
-                    this.mainStore.order.customer.address.city = policy.insureds?.[0]?.city;
-                    this.mainStore.order.customer.address.state = policy.insureds?.[0]?.state;
-                    this.mainStore.order.customer.address.zipCode = policy.insureds?.[0]?.zipCode;
-                    this.mainStore.order.customer.firstName = policy.insureds?.[0]?.firstName;
-                    this.mainStore.order.customer.lastName = policy.insureds?.[0]?.lastName;
-
-                    // populate additional fields
-                    this.mainStore.order.serviceLocation.zipCode = policy.insureds?.[0]?.zipCode;
-
-                    // populate vehicles
-                    this.mainStore.order.policy.vehicles = policy.vehicles;
-                    this.vehiclesFound = policy.vehicles;
-                }
-                return this.navigateForward(policy);
-            }
-            return this.navigateForward();
+                });
         },
 
-        navigateForward(policy) {
-            if (this.duplicates?.length > 0 ?? false) {
+        navigateForward() {
+            if (useMainStore().applicationUser.duplicateOrders?.length > 0 ?? false) {
                 this.$router.navigate(
                     this.navigationScenarios.CLICKED_FORWARD_WITH_DUPLICATES,
                     this.$route,
                     {},
                     { [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
                 );
-            } else if (policy) {
-                if (this.vehiclesFound) {
-                    // if policy lookup is successful and vehicles are found, navigate to policy-vehicles page
+            } else if (this.mainStore.policy.policyLookupSuccessful) {
+                if (this.mainStore.order.policy.vehicles?.length > 0 ?? false) {
+                    // navigate to policy-vehicles page
                     this.$router.navigate(
                         this.navigationScenarios.CLICKED_FORWARD_POLICY_VERIFIED_WITH_VEHICLES,
                         this.$route,
@@ -375,7 +325,6 @@ export default {
                         { [routerParams.SAVE_SESSION_SYNCHRONOUS]: true }
                     );
                 } else {
-                    // if policy lookup is successful, but no vehicles are associated with the policy
                     // navigate to vehicle-selection page (manual entry)
                     this.$router.navigate(
                         this.navigationScenarios.CLICKED_FORWARD_POLICY_VERIFIED_NO_VEHICLES,
diff --git a/src/store/index.js b/src/store/index.js
index 4bb69ffa..90848b05 100644
--- a/src/store/index.js
+++ b/src/store/index.js
@@ -28,7 +28,7 @@ const getDefaultState = () => ({
             imageUrl: null,
             imageVifNumber: null,
             imageColor: null,
-            registration: {
+            registration: { // TODO only licensePlate saved in save session
                 licensePlate: null,
                 address: null,
                 city: null,
@@ -136,15 +136,16 @@ const getDefaultState = () => ({
     },
     applicationUser: {
         experiments: [],
-        eventBus: [],
+        eventBus: [], // TODO not in save session
         pageData: {},
         savedSessionTimeout: getDateForSavedSessionTimeout(),
         saveSessionPromise: null,
         savedSessionId: '00000000-0000-0000-0000-000000000000',
         crmCustomerId: null,
         lastPageVisited: null,
-        triggeredSiteEntry: false,
-        duplicateOrders: []
+        triggeredSiteEntry: false, // TODO not in save session
+        duplicateOrders: [],
+        hasSentSaveQuoteEmail: null
     },
     issConfig: {
         clientName: 'Generic Insurance', // this is the default and will be overriden by the client's name
@@ -365,36 +366,45 @@ export const useMainStore = defineStore({
                 };
             }
         },
-        getCoveragePolicyInfo({ accountNumber, policyNumber, dateOfLoss, zipCode }) {
+        getCoveragePolicyInfo() {
             const { policy } = this.order;
-            try {
-                const response = globalMethods.callHttpClient({
+            return new Promise((resolve, reject) => {
+                globalMethods.callHttpClient({
                     method: endpoints.CoveragePolicyInfo.method,
                     endpoint: endpoints.CoveragePolicyInfo.url,
                     payload: {
-                        accountNumber,
-                        policyNumber,
-                        dateOfLoss,
-                        zipCode,
+                        accountNumber: this.order.accountNumber.toString(),
+                        policyNumber: policy.policyNumber,
+                        dateOfLoss: policy.dateOfLoss,
+                        zipCode: policy.policyZipCode,
                         correlationId: this.order.referralCorrelationId
                     }
                 }).then((r) => {
                     const responsePolicy = r.data.policies?.[0];
                     policy.policyLookupSuccessful = !!responsePolicy;
-                    return r;
+                    if (policy.policyLookupSuccessful) {
+                        const insured = responsePolicy?.insureds?.[0];
+
+                        // populate policy holder details from policy lookup
+                        this.order.customer.address.streetAddress = insured?.address;
+                        this.order.customer.address.city = insured?.city;
+                        this.order.customer.address.state = insured?.state;
+                        this.order.customer.address.zipCode = insured?.zipCode;
+                        this.order.customer.firstName = insured?.firstName;
+                        this.order.customer.lastName = insured?.lastName;
+
+                        // populate additional fields
+                        this.order.serviceLocation.zipCode = insured?.zipCode;
+
+                        // populate vehicles
+                        this.order.policy.vehicles = responsePolicy?.vehicles ?? [];
+                    }
+                    return resolve(r);
                 }).catch((error) => {
                     policy.policyLookupSuccessful = false;
-                    return error;
+                    return reject(error);
                 });
-                return response;
-            } catch (responseError) {
-                policy.policyLookupSuccessful = false;
-                return {
-                    error: {
-                        status: responseError.status
-                    }
-                };
-            }
+            });
         },
         registerClaim() {
             const nonNumberCharRegex = /[^0-9]/g;
@@ -938,72 +948,126 @@ export const useMainStore = defineStore({
         },
 
         loadSession() {
+            const { applicationUser } = this;
             // TODO how to get savedSessionId for a duplicate referral?
-            const result = globalMethods.callHttpClient({
-                method: endpoints.SaveSession.method,
-                endpoint: endpoints.SaveSession.url,
-                payload: {
-                    savedSessionId: this.applicationUser.savedSessionId?.toString(),
-                    referralNumber: this.order.referralNumber?.toString(),
-                    referralDate: this.order.referralDate?.toString(),
-                    parentAccountNumber: this.issConfig.parentAccountNumber,
-                    referralCorrelationId: this.order.referralCorrelationId
-                }
+            return new Promise((resolve, reject) => {
+                globalMethods.callHttpClient({
+                    method: endpoints.LoadSession.method,
+                    endpoint: endpoints.LoadSession.url,
+                    payload: {
+                        savedSessionId: this.applicationUser.savedSessionId?.toString(),
+                        referralNumber: this.order.referralNumber?.toString(),
+                        referralDate: this.order.referralDate?.toString(),
+                        parentAccountNumber: this.issConfig.parentAccountNumber,
+                        referralCorrelationId: this.order.referralCorrelationId
+                    }
+                }).then((result) => {
+                    applicationUser.crmCustomerId = result?.applicationUser?.crmCustomerId;
+                    this.applicationUser.experiments = result?.applicationUser?.experiments;
+                    this.applicationUser.lastPageVisited = result?.applicationUser?.lastPage;
+                    this.applicationUser.pageData = result?.applicationUser?.pageData;
+                    this.applicationUser.savedSessionId = result?.applicationUser?.savedSessionId; // TODO this might just be what is passed
+                    this.applicationUser.hasSentSaveQuoteEmail = result?.applicationUser?.hasSentSaveQuoteEmail;
+
+                    this.order.vehicle.registration.licensePlate = result?.order?.vehicle?.registration?.licensePlateNumber;
+                    this.order.vehicle.imageUrl = result?.order?.vehicle?.imageUrl;
+                    this.order.vehicle.imageColor = result?.order?.vehicle?.imageVifColor;
+                    this.order.vehicle.imageVifNumber = result?.order?.vehicle?.imageVifNumber;
+                    this.order.vehicle.year = result?.order?.vehicle?.year;
+                    this.order.vehicle.make = result?.order?.vehicle?.make;
+                    this.order.vehicle.model = result?.order?.vehicle?.model;
+                    this.order.vehicle.style = result?.order?.vehicle?.style;
+                    this.order.vehicle.carId = result?.order?.vehicle?.carId;
+                    this.order.vehicle.category = result?.order?.vehicle?.category;
+                    this.order.vehicle.vin = result?.order?.vehicle?.vin;
+
+                    this.order.customer.emailAddress = result?.order?.customer?.emailAddress;
+                    this.order.customer.firstName = result?.order?.policy?.policyHolder?.policyFirstName;
+                    this.order.customer.lastName = result?.order?.policy?.policyHolder?.policyLastName;
+                    this.order.customer.phoneNumber = result?.order?.policy?.policyHolder?.policyPhoneNumber;
+                    // TODO policy state
+
+                    this.order.customer.address.streetAddress = result?.order?.customer?.address?.streetAddress;
+                    this.order.customer.address.streetAddress2 = result?.order?.customer?.address?.streetAddress2;
+                    this.order.customer.address.city = result?.order?.customer?.address?.city;
+                    this.order.customer.address.state = result?.order?.customer?.address?.state;
+                    this.order.customer.address.zipCode = result?.order?.customer?.address?.zipCode;
+
+                    this.order.damage.isRepair = result?.order?.damage?.isRepair;
+                    this.order.damage.numberOfChips = result?.order?.damage?.numberOfChips;
+                    this.order.damage.glassToReplace = result?.order?.damage?.glassToReplace; // TODO this might need transformed
+                    this.order.damage.capabilityQuestionAnswers = result?.order?.damage?.capabilityQuestionAnswers;
+                    this.order.damage.moldingQuestionAnswers = result?.order?.damage?.moldingQuestionAnswers;
+                    this.order.damage.partQuestionAnswers = result?.order?.damage?.partQuestionAnswers;
+
+                    this.order.policy.policyNumber = result?.order?.policy?.policyNumber;
+                    this.order.policy.policyZipCode = result?.order?.policy?.policyZipCode;
+                    this.order.policy.noCoverage = result?.order?.policy?.noCoverage;
+                    this.order.policy.policyLookupSuccessful = result?.order?.policy?.policyLookupSuccessful; // TODO probably don't need to load this
+                    this.order.policy.dateOfLoss = result?.order?.damage?.dateOfLoss;
+                    this.order.policy.damageCause = result?.order?.damage?.damageCause;
+                    this.order.policy.damageState = result?.order?.damage?.damageState;
+                    this.order.policy.damageCity = result?.order?.damage?.damageCity;
+                    this.order.policy.isDamageGlassOnly = result?.order?.damage?.isDamageGlassOnly;
+
+                    this.order.originalDeductible = result?.order?.policy?.originalDeductible;
+                    this.order.currentDeductible = result?.order?.policy?.currentDeductible;
+
+                    this.order.lineItems.glassParts = result?.order?.lineItems?.glassParts;
+                    // TODO otherParts
+                    this.order.lineItems.supportingItems = result?.order?.lineItems?.supportingItems;
+                    this.order.lineItems.vaps = result?.order?.lineItems?.vaps;
+
+                    this.order.payment.isInsurance = result?.order?.payment?.isInsurance;
+                    this.order.payment.insuranceCoverage.isVerified = result?.order?.payment?.insuranceCoverage?.isVerified;
+                    this.order.payment.insuranceCoverage.coverageStatus = result?.order?.payment?.insuranceCoverage?.coverageStatus;
+                    this.order.payment.parentAccountNumber = result?.order?.payment?.parentAccountNumber;
+                    this.issConfig.parentAccountNumber = result?.order?.payment?.parentAccountNumber;
+                    // TODO result.order.payment.insuranceCoverage.claimNumber
+
+                    this.order.serviceLocation.address = result?.order?.serviceLocation?.streetAddress;
+                    this.order.serviceLocation.address2 = result?.order?.serviceLocation?.streetAddress2;
+                    this.order.serviceLocation.city = result?.order?.serviceLocation?.city;
+                    this.order.serviceLocation.state = result?.order?.serviceLocation?.state;
+                    this.order.serviceLocation.zipCode = result?.order?.serviceLocation?.zipCode;
+                    this.order.serviceLocation.zipCodeCtu = result?.order?.serviceLocation?.zipCodeCtu;
+                    this.order.serviceLocation.appointmentType = result?.order?.serviceLocation?.appointmentType;
+                    this.order.serviceLocation.isVehicleProtected = result?.order?.serviceLocation?.isVehicleProtected;
+                    this.order.serviceLocation.provider.providerNumber = result?.order?.serviceLocation?.provider?.providerNumber;
+                    this.order.serviceLocation.provider.address.streetAddress = result?.order?.serviceLocation?.provider?.address?.streetAddress;
+                    this.order.serviceLocation.provider.address.city = result?.order?.serviceLocation?.provider?.address?.city;
+                    this.order.serviceLocation.provider.address.state = result?.order?.serviceLocation?.provider?.address?.state;
+                    this.order.serviceLocation.provider.address.zipCode = result?.order?.serviceLocation?.provider?.address?.zipCode;
+                    this.order.serviceLocation.provider.address.zipCodeCtu = result?.order?.serviceLocation?.provider?.address?.zipCodeCtu;
+
+                    this.order.contactInfo.firstName = result?.order?.customer?.firstName;
+                    this.order.contactInfo.lastName = result?.order?.customer?.lastName;
+                    this.order.contactInfo.emailAddress = result?.order?.customer?.emailAddress;
+                    this.order.contactInfo.phoneNumber = result?.order?.customer?.phoneNumber;
+                    this.order.contactInfo.requestTextUpdates = result?.order?.customer?.isSmsOptIn; // TODO confirm
+                    this.order.contactInfo.notesForTechnician = result?.order?.serviceLocation?.techNotes;
+                    // TODO service phone number ??
+                    // TODO isSmsOptIn service ??
+
+                    this.order.schedule.date = result?.order?.schedule?.date;
+                    this.order.schedule.startTime = result?.order?.schedule?.startTime;
+                    this.order.schedule.endTime = result?.order?.schedule?.endTime;
+                    this.order.schedule.routeCode = result?.order?.schedule?.routeCode;
+                    this.order.schedule.jobMaxMinutes = result?.order?.schedule?.jobMaxMinutes;
+                    // TODO result.order.schedule.jobMinMinutes
+
+                    this.order.referralNumber = result?.order?.referralNumber;
+                    this.order.referralDate = result?.order?.referralDate;
+                    this.order.referralCorrelationId = result?.order?.referralCorrelationId;
+                    this.order.referralSequenceNumber = result?.order?.referralSequenceNumber;
+                    this.order.eon = result?.order?.eon;
+                    // TODO this.order.workOrderNumber not set
+                    return resolve(result);
+                }, (error) => {
+                    console.log(error);
+                    reject(error);
+                });
             });
-            this.applicationUser.crmCustomerId = result.applicationUser.crmCustomerId;
-            this.applicationUser.experiments = result.applicationUser.experiments;
-            this.applicationUser.lastPageVisited = result.applicationUser.lastPage;
-            this.applicationUser.pageData = result.applicationUser.pageData;
-            this.applicationUser.savedSessionId = result.applicationUser.savedSessionId; // TODO this might just be what is passed
-
-            this.order.vehicle.registration.licensePlate = result.order.vehicle.registration.licensePlateNumber;
-            this.order.vehicle.imageUrl = result.order.vehicle.imageUrl;
-            this.order.vehicle.imageColor = result.order.vehicle.imageVifColor;
-            this.order.vehicle.imageVifNumber = result.order.vehicle.imageNumber;
-            this.order.vehicle.year = result.order.vehicle.year;
-            this.order.vehicle.make = result.order.vehicle.make;
-            this.order.vehicle.model = result.order.vehicle.model;
-            this.order.vehicle.style = result.order.vehicle.style;
-            this.order.vehicle.carId = result.order.vehicle.carId;
-            this.order.vehicle.category = result.order.vehicle.category;
-            this.order.vehicle.vin = result.order.vehicle.vin;
-
-            this.order.damage.isRepair = result.order.damage.isRepair;
-            this.order.damage.numberOfChips = result.order.damage.numberOfChips;
-            this.order.damage.glassToReplace = result.order.damage.glassToReplace; // TODO this might need transformed
-            this.order.damage.capabilityQuestionAnswers = result.order.damage.capabilityQuestionAnswers;
-            this.order.damage.moldingQuestionAnswers = result.order.damage.moldingQuestionAnswers;
-            this.order.damage.partQuestionAnswers = result.order.damage.partQuestionAnswers;
-
-            this.order.policy.policyNumber = result.order.policy.policyNumber;
-            this.order.policy.policyZipCode = result.order.policy.policyZipCode;
-            this.order.policy.noCoverage = result.order.policy.noCoverage;
-            this.order.policy.policyLookupSuccessful = result.order.policy.policyLookupSuccessful; // TODO probably don't need to load this
-            this.order.policy.dateOfLoss = result.order.damage.dateOfLoss;
-            this.order.policy.damageCause = result.order.damage.damageCause;
-            this.order.policy.damageState = result.order.damage.damageState;
-            this.order.policy.damageCity = result.order.damage.damageCity;
-            this.order.policy.isDamageGlassOnly = result.order.damage.isDamageGlassOnly;
-
-
-            this.order.originalDeductible = result.order.policy.originalDeductible;
-            this.order.currentDeductible = result.order.policies.currentDeductible;
-
-
-            // customer: {
-            //     address: {
-            //         streetAddress: null,
-            //         streetAddress2: null,
-            //         city: null,
-            //         state: null,
-            //         zipCode: null
-            //     },
-            //     firstName: null,
-            //     lastName: null,
-            //     emailAddress: null,
-            //     phoneNumber: null
-            // },
-
         },
 
         setSaveSessionPromise(promise) {
diff --git a/src/store/store.spec.js b/src/store/store.spec.js
index c93d812d..964de2f9 100644
--- a/src/store/store.spec.js
+++ b/src/store/store.spec.js
@@ -492,250 +492,249 @@ describe('Store', () => {
                 store.saveSession();
 
                 // Asserts
-                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                    {
-                        method: endpoints.SaveSession.method,
-                        endpoint: endpoints.SaveSession.url
-                    }
-                ));
+                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                    method: endpoints.SaveSession.method,
+                    endpoint: endpoints.SaveSession.url
+                }));
             });
             it('Returns expected response object', async () => {
                 // Arrange
-                var response = { ReferralNumber: getRandomString(6, 6) };
+                const response = { ReferralNumber: getRandomString(6, 6) };
                 globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response));
 
                 // Act
-                const result = store.saveSession();
+                const result = store.loadSession();
 
                 // Asserts
                 await expect(result).resolves.toBe(response);
-            })
+            });
             it('calls api with expected application user data', () => {
                 // Arrange
-                var applicationUser = {
-                    crmCustomerId: getRandomString(6, 6),
-                    experiments: getRandomString(6, 6),
-                    lastPageVisited: getRandomString(6, 6),
-                    pageData: getRandomString(6, 6),
-                    savedSessionId: getRandomString(6, 6)
-                };
-                store.applicationUser = applicationUser;
-                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
-
-                // Act
-                const result = store.saveSession();
-
-                // Asserts
-                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                    {
-                        payload: expect.objectContaining({
-                            applicationUser: expect.objectContaining({
-                                crmCustomerId: applicationUser.crmCustomerId,
-                                experiments: applicationUser.experiments,
-                                lastPage: applicationUser.lastPageVisited,
-                                pageData: applicationUser.pageData,
-                                savedSessionId: applicationUser.savedSessionId
-                            })
-                        })
-                    })
-                );
-            });
-            it('calls api with expected vehicle', () => {
-                var vehicle = {
-                    year: getRandomString(6, 6),
-                    make: getRandomString(6, 6),
-                    model: getRandomString(6, 6),
-                    style: getRandomString(6, 6),
-                    carId: getRandomString(6, 6),
-                    vin: getRandomString(6, 6),
-                    registration: { licensePlate: getRandomString(6, 6) }
-                };
-                store.order.vehicle = vehicle;
+                const crmCustomerId = getRandomString(6, 6);
+                const experiments = getRandomString(6, 6);
+                const lastPageVisited = getRandomString(6, 6);
+                const pageData = getRandomString(6, 6);
+                const savedSessionId = getRandomString(6, 6);
+                store.applicationUser.crmCustomerId = crmCustomerId;
+                store.applicationUser.experiments = experiments;
+                store.applicationUser.lastPageVisited = lastPageVisited;
+                store.applicationUser.pageData = pageData;
+                store.applicationUser.savedSessionId = savedSessionId;
                 globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
 
                 // Act
                 store.saveSession();
 
                 // Asserts
-                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                    {
-                        payload: expect.objectContaining({
-                            vehicle: expect.objectContaining({
-                                year: vehicle.year,
-                                make: vehicle.make,
-                                model: vehicle.model,
-                                style: vehicle.style,
-                                carId: vehicle.carId,
-                                vin: vehicle.vin,
-                                licensePlateNumber: vehicle.registration.licensePlate
-                            })
+                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                    payload: expect.objectContaining({
+                        applicationUser: expect.objectContaining({
+                            crmCustomerId,
+                            experiments,
+                            lastPage: lastPageVisited,
+                            pageData,
+                            savedSessionId
                         })
-                    }
-                ));
+                    })
+                }));
+            });
+            it('calls api with expected vehicle', () => {
+                const year = getRandomString(6, 6);
+                const make = getRandomString(6, 6);
+                const model = getRandomString(6, 6);
+                const style = getRandomString(6, 6);
+                const carId = getRandomString(6, 6);
+                const vin = getRandomString(6, 6);
+                const licensePlate = getRandomString(6, 6);
+                store.order.vehicle.year = year;
+                store.order.vehicle.make = make;
+                store.order.vehicle.model = model;
+                store.order.vehicle.style = style;
+                store.order.vehicle.carId = carId;
+                store.order.vehicle.vin = vin;
+                store.order.vehicle.registration.licensePlate = licensePlate;
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
+
+                // Act
+                store.saveSession();
+
+                // Asserts
+                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                    payload: expect.objectContaining({
+                        vehicle: expect.objectContaining({
+                            year,
+                            make,
+                            model,
+                            style,
+                            carId,
+                            vin,
+                            licensePlateNumber: licensePlate
+                        })
+                    })
+                }));
             });
             it('calls api with expected damage', () => {
                 // Arrange
-                var damage = {
-                    isRepair: getRandomString(6, 6),
-                    numberOfChips: getRandomString(6, 6),
-                    glassToReplace: [],
-                    partQuestionAnswers: getRandomString(6, 6),
-                    moldingQuestionAnswers: getRandomString(6, 6),
-                    capabilityQuestionAnswers: getRandomString(6, 6)
-                };
-                var policy = {
-                    dateOfLoss: getRandomString(6, 6),
-                    damageCause: getRandomString(6, 6),
-                    damageState: getRandomString(6, 6),
-                    damageCity: getRandomString(6, 6),
-                    isDamageGlassOnly: getRandomString(6, 6)
-                };
-                store.order.damage = damage;
-                store.order.policy = policy;
+                const isRepair = getRandomString(6, 6);
+                const numberOfChips = getRandomString(6, 6);
+                const partQuestionAnswers = getRandomString(6, 6);
+                const moldingQuestionAnswers = getRandomString(6, 6);
+                const capabilityQuestionAnswers = getRandomString(6, 6);
+                const dateOfLoss = getRandomString(6, 6);
+                const damageCause = getRandomString(6, 6);
+                const damageState = getRandomString(6, 6);
+                const damageCity = getRandomString(6, 6);
+                const isDamageGlassOnly = getRandomString(6, 6);
+                store.order.damage.isRepair = isRepair;
+                store.order.damage.numberOfChips = numberOfChips;
+                store.order.damage.partQuestionAnswers = partQuestionAnswers;
+                store.order.damage.moldingQuestionAnswers = moldingQuestionAnswers;
+                store.order.damage.capabilityQuestionAnswers = capabilityQuestionAnswers;
+                store.order.policy.dateOfLoss = dateOfLoss;
+                store.order.policy.damageCause = damageCause;
+                store.order.policy.damageState = damageState;
+                store.order.policy.damageCity = damageCity;
+                store.order.policy.isDamageGlassOnly = isDamageGlassOnly;
                 globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
 
                 // Act
                 store.saveSession();
 
                 // Assert
-                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                    {
-                        payload: expect.objectContaining({
-                            damage: expect.objectContaining({
-                                numberOfChips: damage.numberOfChips,
-                                isRepair: damage.isRepair,
-                                partQuestionAnswers: damage.partQuestionAnswers,
-                                moldingQuestionAnswers: damage.moldingQuestionAnswers,
-                                capabilityQuestionAnswers: damage.capabilityQuestionAnswers,
-                                dateOfLoss: policy.dateOfLoss,
-                                damageCause: policy.damageCause,
-                                damageState: policy.damageState,
-                                damageCity: policy.damageCity,
-                                isDamageGlassOnly: policy.isDamageGlassOnly
-                            })
+                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                    payload: expect.objectContaining({
+                        damage: expect.objectContaining({
+                            numberOfChips,
+                            isRepair,
+                            partQuestionAnswers,
+                            moldingQuestionAnswers,
+                            capabilityQuestionAnswers,
+                            dateOfLoss,
+                            damageCause,
+                            damageState,
+                            damageCity,
+                            isDamageGlassOnly
                         })
                     })
-                );
+                }));
             });
             it('calls api with expected policy', () => {
                 // Arrange
-                var customer = {
-                    firstName: getRandomString(6, 6),
-                    lastName: getRandomString(6, 6),
-                    emailAddress: getRandomString(6, 6),
-                    phoneNumber: getRandomString(6, 6)
-                };
-                var policy = {
-                    policyNumber: getRandomString(6, 6),
-                    policyZipCode: getRandomString(6, 6),
-                    policyLookupSuccessful: getRandomString(6, 6),
-                    noCoverage: getRandomString(6, 6)
-                };
-                var originalDeductible = getRandomString(6, 6);
-                var currentDeductible = getRandomString(6, 6);
+                const customerFirstName = getRandomString(6, 6);
+                const customerLastName = getRandomString(6, 6);
+                const customerEmail = getRandomString(6, 6);
+                const customerPhoneNumber = getRandomString(6, 6);
+                const policyNumber = getRandomString(6, 6);
+                const policyZipCode = getRandomString(6, 6);
+                const policyLookupSuccessful = getRandomString(6, 6);
+                const noCoverage = getRandomString(6, 6);
+                const originalDeductible = getRandomString(6, 6);
+                const currentDeductible = getRandomString(6, 6);
                 store.order.originalDeductible = originalDeductible;
                 store.order.currentDeductible = currentDeductible;
-                store.order.customer = customer;
-                store.order.policy = policy;
+                store.order.customer.firstName = customerFirstName;
+                store.order.customer.lastName = customerLastName;
+                store.order.customer.emailAddress = customerEmail;
+                store.order.customer.phoneNumber = customerPhoneNumber;
+                store.order.policy.policyNumber = policyNumber;
+                store.order.policy.policyZipCode = policyZipCode;
+                store.order.policy.policyLookupSuccessful = policyLookupSuccessful;
+                store.order.policy.noCoverage = noCoverage;
                 globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
 
                 // Act
                 store.saveSession();
 
                 // Asserts
-                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                    {
-                        payload: expect.objectContaining({
-                            policy: expect.objectContaining({
-                                policyHolder: expect.objectContaining({
-                                    policyFirstName: customer.firstName,
-                                    policyLastName: customer.lastName,
-                                    policyPhoneNumber: customer.phoneNumber,
-                                    policyEmail: customer.emailAddress
-                                }),
-                                policyNumber: policy.policyNumber,
-                                policyZipCode: policy.policyZipCode,
-                                noCoverage: policy.noCoverage,
-                                policyLookupSuccessful: policy.policyLookupSuccessful,
-                                originalDeductible,
-                                currentDeductible
-                            })
+                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                    payload: expect.objectContaining({
+                        policy: expect.objectContaining({
+                            policyHolder: expect.objectContaining({
+                                policyFirstName: customerFirstName,
+                                policyLastName: customerLastName,
+                                policyPhoneNumber: customerPhoneNumber,
+                                policyEmail: customerEmail
+                            }),
+                            policyNumber,
+                            policyZipCode,
+                            noCoverage,
+                            policyLookupSuccessful,
+                            originalDeductible,
+                            currentDeductible
                         })
                     })
-                );
+                }));
             });
             it('calls api with expected customer', () => {
                 // Arrange
-                var customer = {
-                    address: {
-                        streetAddress: getRandomString(6, 6),
-                        streetAddress2: getRandomString(6, 6),
-                        city: getRandomString(6, 6),
-                        state: getRandomString(6, 6),
-                        zipCode: getRandomString(6, 6)
-                    }
-                };
-                var contactInfo = {
-                    firstName: getRandomString(6, 6),
-                    lastName: getRandomString(6, 6),
-                    emailAddress: getRandomString(6, 6),
-                    phoneNumber: getRandomString(6, 6),
-                    requestTextUpdates: getRandomBoolean()
-                };
-                store.order.contactInfo = contactInfo;
-                store.order.customer = customer;
+                const streetAddress = getRandomString(6, 6);
+                const streetAddress2 = getRandomString(6, 6);
+                const city = getRandomString(6, 6);
+                const state = getRandomString(6, 6);
+                const zipCode = getRandomString(6, 6);
+                const contactFirstName = getRandomString(6, 6);
+                const contactLastName = getRandomString(6, 6);
+                const contactEmail = getRandomString(6, 6);
+                const contactPhoneNumber = getRandomString(6, 6);
+                const requestTextUpdates = getRandomBoolean();
+                store.order.contactInfo.firstName = contactFirstName;
+                store.order.contactInfo.lastName = contactLastName;
+                store.order.contactInfo.emailAddress = contactEmail;
+                store.order.contactInfo.phoneNumber = contactPhoneNumber;
+                store.order.contactInfo.requestTextUpdates = requestTextUpdates;
+                store.order.customer.address.streetAddress = streetAddress;
+                store.order.customer.address.streetAddress2 = streetAddress2;
+                store.order.customer.address.city = city;
+                store.order.customer.address.state = state;
+                store.order.customer.address.zipCode = zipCode;
                 globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
 
                 // Act
                 store.saveSession();
 
                 // Assert
-                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                    {
-                        payload: expect.objectContaining({
-                            customer: expect.objectContaining({
-                                address: expect.objectContaining({
-                                    streetAddress: customer.address.streetAddress,
-                                    streetAddress2: customer.address.streetAddress2,
-                                    city: customer.address.city,
-                                    state: customer.address.state,
-                                    zipCode: customer.address.zipCode
-                                }),
-                                emailAddress: contactInfo.emailAddress,
-                                firstName: contactInfo.firstName,
-                                lastName: contactInfo.lastName,
-                                phoneNumber: contactInfo.phoneNumber,
-                                optInSms: contactInfo.requestTextUpdates
-                            })
+                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                    payload: expect.objectContaining({
+                        customer: expect.objectContaining({
+                            address: expect.objectContaining({
+                                streetAddress,
+                                streetAddress2,
+                                city,
+                                state,
+                                zipCode
+                            }),
+                            emailAddress: contactEmail,
+                            firstName: contactFirstName,
+                            lastName: contactLastName,
+                            phoneNumber: contactPhoneNumber,
+                            optInSms: requestTextUpdates
                         })
                     })
-                );
+                }));
             });
             it('calls api with expected lineItems', () => {
                 // Arrange
-                var lineItems = {
-                    glassParts: getRandomString(6, 6),
-                    supportingItems: getRandomString(6, 6),
-                    vaps: getRandomString(6, 6)
-                };
-                store.order.lineItems = lineItems;
+                const glassParts = getRandomString(6, 6);
+                const supportingItems = getRandomString(6, 6);
+                const vaps = getRandomString(6, 6);
+                store.order.lineItems.glassParts = glassParts;
+                store.order.lineItems.supportingItems = supportingItems;
+                store.order.lineItems.vaps = vaps;
                 globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
 
                 // Act
                 store.saveSession();
 
                 // Assert
-                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                    {
-                        payload: expect.objectContaining({
-                            lineItems: expect.objectContaining({
-                                glassParts: lineItems.glassParts,
-                                supportingItems: lineItems.supportingItems,
-                                vaps: lineItems.vaps
-                            })
+                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                    payload: expect.objectContaining({
+                        lineItems: expect.objectContaining({
+                            glassParts,
+                            supportingItems,
+                            vaps
                         })
                     })
-                );
+                }));
             });
             it.each([
                 [coverageStatuses.PENDING],
@@ -744,132 +743,123 @@ describe('Store', () => {
             ])('calls api with expected payment', (coverageStatus) => {
                 // Arrange
                 const parentAccountNumber = getRandomString(6, 6);
-                const payment = {
-                    isInsurance: getRandomBoolean(),
-                    insuranceCoverage: {
-                        isVerified: getRandomBoolean(),
-                        coverageStatus
-                    }
-                };
+                const isInsurance = getRandomBoolean();
+                const isVerified = getRandomBoolean();
                 store.issConfig.parentAccountNumber = parentAccountNumber;
-                store.order.payment = payment;
+                store.order.payment.isInsurance = isInsurance;
+                store.order.payment.insuranceCoverage.isVerified = isVerified;
+                store.order.payment.insuranceCoverage.coverageStatus = coverageStatus;
                 globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
 
                 // Act
                 store.saveSession();
 
                 // Assert
-                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                    {
-                        payload: expect.objectContaining({
-                            payment: expect.objectContaining({
-                                InsuranceCoverage: expect.objectContaining({
-                                    isVerified: payment.insuranceCoverage.isVerified,
-                                    coverageStatus: coverageStatus
-                                }),
-                                isInsurance: payment.isInsurance,
-                                parentAccountNumber: parentAccountNumber
-                            })
+                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                    payload: expect.objectContaining({
+                        payment: expect.objectContaining({
+                            InsuranceCoverage: expect.objectContaining({
+                                isVerified,
+                                coverageStatus
+                            }),
+                            isInsurance,
+                            parentAccountNumber
                         })
                     })
-                );
+                }));
             });
             it('calls api with expected service location', () => {
                 // Arrange
-                var notesForTechnician = getRandomString(6, 6);
-                var serviceLocation = {
-                    address: getRandomString(6, 6),
-                    city: getRandomString(6, 6),
-                    state: getRandomString(6, 6),
-                    zipCode: getRandomString(6, 6),
-                    zipCodeCtu: getRandomString(6, 6)
-                };
+                const notesForTechnician = getRandomString(6, 6);
+                const address = getRandomString(6, 6);
+                const city = getRandomString(6, 6);
+                const state = getRandomString(6, 6);
+                const zipCode = getRandomString(6, 6);
+                const zipCodeCtu = getRandomString(6, 6);
                 store.order.contactInfo.notesForTechnician = notesForTechnician;
-                store.order.serviceLocation = serviceLocation;
+                store.order.serviceLocation.address = address;
+                store.order.serviceLocation.city = city;
+                store.order.serviceLocation.state = state;
+                store.order.serviceLocation.zipCode = zipCode;
+                store.order.serviceLocation.zipCodeCtu = zipCodeCtu;
                 globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
 
                 // Act
                 store.saveSession();
 
                 // Assert
-                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                    {
-                        payload: expect.objectContaining({
-                            serviceLocation: expect.objectContaining({
-                                address: expect.objectContaining({
-                                    streetAddress: serviceLocation.address,
-                                    city: serviceLocation.city,
-                                    state: serviceLocation.state,
-                                    zipCode: serviceLocation.zipCode,
-                                    zipCodeCtu: serviceLocation.zipCodeCtu
-                                }),
-                                techNotes: notesForTechnician
-                            })
+                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                    payload: expect.objectContaining({
+                        serviceLocation: expect.objectContaining({
+                            address: expect.objectContaining({
+                                streetAddress: address,
+                                city,
+                                state,
+                                zipCode,
+                                zipCodeCtu
+                            }),
+                            techNotes: notesForTechnician
                         })
                     })
-                );
+                }));
             });
             it('calls api with expected schedule', () => {
                 // Arrange
-                var schedule = {
-                    date: getRandomString(6, 6),
-                    startTime: getRandomString(6, 6),
-                    endTime: getRandomString(6, 6),
-                    routeCode: getRandomString(6, 6),
-                    jobMaxMinutes: getRandomString(6, 6)
-                };
-                store.order.schedule = schedule;
+                const date = getRandomString(6, 6);
+                const startTime = getRandomString(6, 6);
+                const endTime = getRandomString(6, 6);
+                const routeCode = getRandomString(6, 6);
+                const jobMaxMinutes = getRandomString(6, 6);
+                store.order.schedule.date = date;
+                store.order.schedule.startTime = startTime;
+                store.order.schedule.endTime = endTime;
+                store.order.schedule.routeCode = routeCode;
+                store.order.schedule.jobMaxMinutes = jobMaxMinutes;
                 globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
 
                 // Act
                 store.saveSession();
 
                 // Assert
-                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                    {
-                        payload: expect.objectContaining({
-                            schedule: expect.objectContaining({
-                                date: schedule.date,
-                                startTime: schedule.startTime,
-                                endTime: schedule.endTime,
-                                routeCode: schedule.routeCode,
-                                jobMaxMinutes: schedule.jobMaxMinutes
-                            })
+                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                    payload: expect.objectContaining({
+                        schedule: expect.objectContaining({
+                            date,
+                            startTime,
+                            endTime,
+                            routeCode,
+                            jobMaxMinutes
                         })
                     })
-                );
+                }));
             });
             it('calls api with expected referral date', () => {
                 // Arrange
-                var referralDate = getRandomString(6, 6);
+                const referralDate = getRandomString(6, 6);
                 store.order.referralDate = referralDate;
                 globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
 
                 // Act
                 store.saveSession();
-                
+
                 // Assert
-                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                    {
-                        payload: expect.objectContaining({ referralDate: referralDate })
-                    })
-                );
+                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                    payload: expect.objectContaining({ referralDate })
+                }));
             });
             it('calls api with expected referral number', () => {
                 // Arrange
-                var referralNumber = getRandomString(6, 6);
+                const referralNumber = getRandomString(6, 6);
                 store.order.referralNumber = referralNumber;
                 globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
 
                 // Act
                 store.saveSession();
-                
+
                 // Assert
-                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                    {
-                        payload: expect.objectContaining({ referralNumber: referralNumber })
-                    }
-                ));
+                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                    payload: expect.objectContaining({ referralNumber })
+                }));
             });
         });
         it('No glassArray => empty list', async () => {
@@ -880,15 +870,13 @@ describe('Store', () => {
             await store.saveSession();
 
             // Asserts
-            expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                {
-                    payload: expect.objectContaining({
-                        damage: expect.objectContaining({
-                            glassToReplace: []
-                        })
+            expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                payload: expect.objectContaining({
+                    damage: expect.objectContaining({
+                        glassToReplace: []
                     })
                 })
-            );
+            }));
         });
         it('glassArray empty => empty list', async () => {
             store.damage.glassToReplace = [];
@@ -898,15 +886,13 @@ describe('Store', () => {
             await store.saveSession();
 
             // Asserts
-            expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                {
-                    payload: expect.objectContaining({
-                        damage: expect.objectContaining({
-                            glassToReplace: []
-                        })
+            expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                payload: expect.objectContaining({
+                    damage: expect.objectContaining({
+                        glassToReplace: []
                     })
                 })
-            );
+            }));
         });
         it('Nonempty glass array => expected glass array sent', async () => {
             const location1 = getRandomString(5);
@@ -914,27 +900,25 @@ describe('Store', () => {
             const name1 = getRandomString(10);
             const name2 = getRandomString(10);
             store.damage.glassToReplace = [
-                {glassLocation: location1, glassName: name1}, 
-                {glassLocation: location2, glassName: name2}
-            ],
+                { glassLocation: location1, glassName: name1 },
+                { glassLocation: location2, glassName: name2 }
+            ];
             globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
 
             // Act
             await store.saveSession();
 
             // Asserts
-            expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                {
-                    payload: expect.objectContaining({
-                        damage: expect.objectContaining({
-                            glassToReplace: expect.arrayContaining([
-                                {location: location1, name: name1},
-                                {location: location2, name: name2}
-                            ])
-                        })
+            expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                payload: expect.objectContaining({
+                    damage: expect.objectContaining({
+                        glassToReplace: expect.arrayContaining([
+                            { location: location1, name: name1 },
+                            { location: location2, name: name2 }
+                        ])
                     })
                 })
-            );
+            }));
         });
         it('api call throws exception', async () => {
             expect.assertions(2);
@@ -947,12 +931,401 @@ describe('Store', () => {
             });
 
             // Asserts
-            expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining(
-                {
-                    method: endpoints.SaveSession.method,
-                    endpoint: endpoints.SaveSession.url
-                })
-            );
+            expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                method: endpoints.SaveSession.method,
+                endpoint: endpoints.SaveSession.url
+            }));
+        });
+    });
+
+    describe('loadSession method', () => {
+        describe('successful method call', () => {
+            const applicationUser = {
+                crmCustomerId: getRandomString(6, 6),
+                experiments: getRandomString(6, 6),
+                lastPage: getRandomString(6, 6),
+                pageData: getRandomString(6, 6),
+                savedSessionId: getRandomString(6, 6),
+                hasSentSaveQuoteEmail: getRandomBoolean()
+            };
+            const vehicle = {
+                year: getRandomString(6, 6),
+                make: getRandomString(6, 6),
+                model: getRandomString(6, 6),
+                style: getRandomString(6, 6),
+                vin: getRandomString(6, 6),
+                carId: getRandomString(6, 6),
+                category: getRandomString(6, 6),
+                registration: {
+                    licensePlateNumber: getRandomString(6, 6)
+                },
+                imageUrl: getRandomString(6, 6),
+                imageVifNumber: getRandomString(6, 6),
+                imageVifColor: getRandomString(6, 6)
+            };
+            const damage = {
+                numberOfChips: getRandomString(6, 6),
+                isRepair: getRandomBoolean(),
+                glassToReplace: getRandomString(6, 6),
+                capabilityQuestionAnswers: getRandomString(6, 6),
+                moldingQuestionAnswers: getRandomString(6, 6),
+                partQuestionAnswers: getRandomString(6, 6),
+                dateOfLoss: getRandomString(6, 6),
+                damageCause: getRandomString(6, 6),
+                damageState: getRandomString(6, 6),
+                damageCity: getRandomString(6, 6),
+                isDamageGlassOnly: getRandomBoolean()
+            };
+            const policy = {
+                policyNumber: getRandomString(6, 6),
+                policyZipCode: getRandomBoolean(),
+                noCoverage: getRandomString(6, 6),
+                policyLookupSuccessful: getRandomBoolean(),
+                policyHolder: {
+                    policyFirstName: getRandomString(6, 6),
+                    policyLastName: getRandomString(6, 6),
+                    policyPhoneNumber: getRandomString(6, 6),
+                    policyState: getRandomString(6, 6)
+                },
+                originalDeductible: getRandomString(6, 6),
+                currentDeductible: getRandomString(6, 6)
+            };
+            const customer = {
+                firstName: getRandomString(6, 6),
+                lastName: getRandomString(6, 6),
+                emailAddress: getRandomString(6, 6),
+                phoneNumber: getRandomString(6, 6),
+                isSmsOptIn: getRandomString(6, 6),
+                address: {
+                    streetAddress: getRandomString(6, 6),
+                    streetAddress2: getRandomString(6, 6),
+                    city: getRandomString(6, 6),
+                    state: getRandomString(6, 6),
+                    zipCode: getRandomString(6, 6),
+                    zipCodeCtu: getRandomString(6, 6)
+                }
+            };
+            const provider = {
+                providerNumber: getRandomString(6, 6),
+                address: {
+                    streetAddress: getRandomString(6, 6),
+                    streetAddress2: getRandomString(6, 6),
+                    city: getRandomString(6, 6),
+                    state: getRandomString(6, 6),
+                    zipCode: getRandomString(6, 6),
+                    zipCodeCtu: getRandomString(6, 6)
+                }
+            };
+            const serviceLocation = {
+                streetAddress: getRandomString(6, 6),
+                streetAddress2: getRandomString(6, 6),
+                city: getRandomString(6, 6),
+                state: getRandomString(6, 6),
+                zipCode: getRandomString(6, 6),
+                zipCodeCtu: getRandomString(6, 6),
+                appointmentType: getRandomString(6, 6),
+                isVehicleProtected: getRandomBoolean(),
+                provider,
+                techNotes: getRandomString(6, 6),
+                phoneNumber: getRandomString(6, 6),
+                isSmsOptIn: getRandomBoolean()
+            };
+            const lineItems = {
+                glassParts: getRandomString(6, 6),
+                supportingItems: getRandomString(6, 6),
+                vaps: getRandomString(6, 6),
+                serverData: getRandomString(6, 6)
+            };
+            const payment = {
+                insuranceCoverage: {
+                    isVerified: getRandomBoolean(),
+                    coverageStatus: getRandomString(6, 6),
+                    claimNumber: getRandomString(6, 6)
+                },
+                isInsurance: getRandomString(6, 6),
+                parentAccountNumber: getRandomString(6, 6)
+            };
+            const schedule = {
+                date: getRandomString(6, 6),
+                startTime: getRandomString(6, 6),
+                endTime: getRandomString(6, 6),
+                routeCode: getRandomString(6, 6),
+                jobMaxMinutes: getRandomString(6, 6),
+                jobMinMinutes: getRandomString(6, 6)
+            };
+            const fullApiResponse = {
+                applicationUser,
+                order: {
+                    vehicle,
+                    damage,
+                    policy,
+                    customer,
+                    serviceLocation,
+                    lineItems,
+                    payment,
+                    schedule,
+                    referralNumber: getRandomString(6, 6),
+                    referralDate: getRandomString(6, 6),
+                    referralCorrelationId: getRandomString(6, 6),
+                    referralSequenceNumber: getRandomString(6, 6),
+                    eon: getRandomString(6, 6)
+                }
+            };
+            it('calls load session api endpoint', async () => {
+                // Arrange
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve({}));
+
+                // Act
+                store.loadSession();
+
+                // Asserts
+                expect(globalMethods.callHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                    method: endpoints.LoadSession.method,
+                    endpoint: endpoints.LoadSession.url
+                }));
+            });
+            it('Returns expected response object', async () => {
+                // Arrange
+                const response = { ReferralNumber: getRandomString(6, 6) };
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(response));
+
+                // Act
+                const result = store.loadSession();
+
+                // Asserts
+                await expect(result).resolves.toBe(response);
+            });
+            it('sets expected application user data', async () => {
+                // Arrange
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
+                const originalSavedSessionTimeout = store.applicationUser.savedSessionTimeout;
+                const originalEventBus = store.applicationUser.eventBus;
+                const originalSaveSessionPromise = store.applicationUser.saveSessionPromise;
+                const originalTriggeredSiteEntry = store.applicationUser.triggeredSiteEntry;
+                const originalDuplicateOrders = store.applicationUser.duplicateOrders;
+
+                // Act
+                await store.loadSession();
+
+                // Asserts
+                expect(store.applicationUser.experiments).toEqual(applicationUser.experiments);
+                expect(store.applicationUser.pageData).toBe(applicationUser.pageData);
+                expect(store.applicationUser.savedSessionId).toBe(applicationUser.savedSessionId);
+                expect(store.applicationUser.crmCustomerId).toBe(applicationUser.crmCustomerId);
+                expect(store.applicationUser.lastPageVisited).toBe(applicationUser.lastPage);
+                expect(store.applicationUser.hasSentSaveQuoteEmail).toBe(applicationUser.hasSentSaveQuoteEmail);
+                expect(store.applicationUser.eventBus).toEqual(originalEventBus);
+                expect(store.applicationUser.savedSessionTimeout).toBe(originalSavedSessionTimeout);
+                expect(store.applicationUser.saveSessionPromise).toBe(originalSaveSessionPromise);
+                expect(store.applicationUser.triggeredSiteEntry).toBe(originalTriggeredSiteEntry);
+                expect(store.applicationUser.duplicateOrders).toEqual(originalDuplicateOrders);
+            });
+            it('sets expected vehicle data', async () => {
+                // Arrange
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
+                const originalRegistrationAddress = store.vehicle.registration.address;
+                const originalRegistrationCity = store.vehicle.registration.city;
+                const originalRegistrationState = store.vehicle.registration.state;
+                const originalRegistrationZipCode = store.vehicle.registration.zipCode;
+                const originalRegistrationFirstName = store.vehicle.registration.firstName;
+                const originalRegistrationLastName = store.vehicle.registration.lastName;
+
+                // Act
+                await store.loadSession();
+
+                // Asserts
+                expect(store.vehicle.year).toBe(vehicle.year);
+                expect(store.vehicle.make).toBe(vehicle.make);
+                expect(store.vehicle.model).toBe(vehicle.model);
+                expect(store.vehicle.style).toBe(vehicle.style);
+                expect(store.vehicle.carId).toBe(vehicle.carId);
+                expect(store.vehicle.category).toBe(vehicle.category);
+                expect(store.vehicle.vin).toBe(vehicle.vin);
+                expect(store.vehicle.imageUrl).toBe(vehicle.imageUrl);
+                expect(store.vehicle.imageVifNumber).toBe(vehicle.imageVifNumber);
+                expect(store.vehicle.imageColor).toBe(vehicle.imageVifColor);
+                expect(store.vehicle.registration.licensePlate).toBe(vehicle.registration.licensePlateNumber);
+                expect(store.vehicle.registration.address).toBe(originalRegistrationAddress);
+                expect(store.vehicle.registration.city).toBe(originalRegistrationCity);
+                expect(store.vehicle.registration.state).toBe(originalRegistrationState);
+                expect(store.vehicle.registration.zipCode).toBe(originalRegistrationZipCode);
+                expect(store.vehicle.registration.firstName).toBe(originalRegistrationFirstName);
+                expect(store.vehicle.registration.lastName).toBe(originalRegistrationLastName);
+            });
+            it('sets expected damage data', async () => {
+                // Arrange
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
+
+                // Act
+                await store.loadSession();
+
+                // Asserts
+                expect(store.damage.isRepair).toBe(damage.isRepair);
+                expect(store.damage.numberOfChips).toBe(damage.numberOfChips);
+                expect(store.damage.glassToReplace).toBe(damage.glassToReplace);
+                expect(store.damage.partQuestionAnswers).toBe(damage.partQuestionAnswers);
+                expect(store.damage.moldingQuestionAnswers).toBe(damage.moldingQuestionAnswers);
+                expect(store.damage.capabilityQuestionAnswers).toBe(damage.capabilityQuestionAnswers);
+            });
+            it('sets expected policy data', async () => {
+                // Arrange
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
+                const originalRepairDeductible = store.policy.deductible.repair;
+                const originalReplaceDeductible = store.policy.deductible.replace;
+                const originalVehicles = store.policy.vehicles;
+                const originalEndorsementQuestionAnswers = store.policy.endorsementQuestionAnswers;
+
+                // Act
+                await store.loadSession();
+
+                // Asserts
+                expect(store.policy.policyNumber).toBe(policy.policyNumber);
+                expect(store.policy.policyZipCode).toBe(policy.policyZipCode);
+                expect(store.policy.dateOfLoss).toBe(damage.dateOfLoss);
+                expect(store.policy.damageCause).toBe(damage.damageCause);
+                expect(store.policy.damageState).toBe(damage.damageState);
+                expect(store.policy.damageCity).toBe(damage.damageCity);
+                expect(store.policy.isDamageGlassOnly).toBe(damage.isDamageGlassOnly);
+                expect(store.policy.policyLookupSuccessful).toBe(policy.policyLookupSuccessful);
+                expect(store.policy.noCoverage).toBe(policy.noCoverage);
+                expect(store.policy.deductible.repair).toBe(originalRepairDeductible);
+                expect(store.policy.deductible.replace).toBe(originalReplaceDeductible);
+                expect(store.policy.vehicles).toEqual(originalVehicles);
+                expect(store.policy.endorsementQuestionAnswers).toBe(originalEndorsementQuestionAnswers);
+            });
+            it('sets expected customer data', async () => {
+                // Arrange
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
+
+                // Act
+                await store.loadSession();
+
+                // Asserts
+                expect(store.order.customer.address.streetAddress).toBe(customer.address.streetAddress);
+                expect(store.order.customer.address.streetAddress2).toBe(customer.address.streetAddress2);
+                expect(store.order.customer.address.city).toBe(customer.address.city);
+                expect(store.order.customer.address.state).toBe(customer.address.state);
+                expect(store.order.customer.address.zipCode).toBe(customer.address.zipCode);
+                expect(store.order.customer.firstName).toBe(policy.policyHolder.policyFirstName);
+                expect(store.order.customer.lastName).toBe(policy.policyHolder.policyLastName);
+                expect(store.order.customer.emailAddress).toBe(customer.emailAddress);
+                expect(store.order.customer.phoneNumber).toBe(policy.policyHolder.policyPhoneNumber);
+            });
+            it('sets expected serviceLocation data', async () => {
+                // Arrange
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
+
+                // Act
+                await store.loadSession();
+
+                // Asserts
+                expect(store.order.serviceLocation.address).toBe(serviceLocation.streetAddress);
+                expect(store.order.serviceLocation.address2).toBe(serviceLocation.streetAddress2);
+                expect(store.order.serviceLocation.city).toBe(serviceLocation.city);
+                expect(store.order.serviceLocation.state).toBe(serviceLocation.state);
+                expect(store.order.serviceLocation.zipCode).toBe(serviceLocation.zipCode);
+                expect(store.order.serviceLocation.zipCodeCtu).toBe(serviceLocation.zipCodeCtu);
+                expect(store.order.serviceLocation.appointmentType).toBe(serviceLocation.appointmentType);
+                expect(store.order.serviceLocation.isVehicleProtected).toBe(serviceLocation.isVehicleProtected);
+                expect(store.order.serviceLocation.provider.providerNumber).toBe(provider.providerNumber);
+                expect(store.order.serviceLocation.provider.address.streetAddress).toBe(provider.address.streetAddress);
+                expect(store.order.serviceLocation.provider.address.city).toBe(provider.address.city);
+                expect(store.order.serviceLocation.provider.address.state).toBe(provider.address.state);
+                expect(store.order.serviceLocation.provider.address.zipCode).toBe(provider.address.zipCode);
+                expect(store.order.serviceLocation.provider.address.zipCodeCtu).toBe(provider.address.zipCodeCtu);
+            });
+            it('sets expected lineItems data', async () => {
+                // Arrange
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
+                const originalOtherParts = store.order.lineItems.otherParts;
+
+                // Act
+                await store.loadSession();
+
+                // Asserts
+                expect(store.order.lineItems.glassParts).toBe(lineItems.glassParts);
+                expect(store.order.lineItems.otherParts).toBe(originalOtherParts);
+                expect(store.order.lineItems.supportingItems).toBe(lineItems.supportingItems);
+                expect(store.order.lineItems.vaps).toBe(lineItems.vaps);
+            });
+            it('sets expected payment data', async () => {
+                // Arrange
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
+
+                // Act
+                await store.loadSession();
+
+                // Asserts
+                expect(store.order.payment.isInsurance).toBe(payment.isInsurance);
+                expect(store.order.payment.insuranceCoverage.isVerified).toBe(payment.insuranceCoverage.isVerified);
+                expect(store.order.payment.insuranceCoverage.coverageStatus).toBe(payment.insuranceCoverage.coverageStatus);
+                expect(store.order.payment.parentAccountNumber).toBe(payment.parentAccountNumber);
+                expect(store.issConfig.parentAccountNumber).toBe(payment.parentAccountNumber);
+            });
+            it('sets expected contactInfo data', async () => {
+                // Arrange
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
+
+                // Act
+                await store.loadSession();
+
+                // Asserts
+                expect(store.order.contactInfo.firstName).toBe(customer.firstName);
+                expect(store.order.contactInfo.lastName).toBe(customer.lastName);
+                expect(store.order.contactInfo.emailAddress).toBe(customer.emailAddress);
+                expect(store.order.contactInfo.phoneNumber).toBe(customer.phoneNumber);
+                expect(store.order.contactInfo.requestTextUpdates).toBe(customer.isSmsOptIn);
+                expect(store.order.contactInfo.notesForTechnician).toBe(serviceLocation.techNotes);
+            });
+            it('sets expected schedule data', async () => {
+                // Arrange
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
+
+                // Act
+                await store.loadSession();
+
+                // Asserts
+                expect(store.order.schedule.date).toBe(schedule.date);
+                expect(store.order.schedule.startTime).toBe(schedule.startTime);
+                expect(store.order.schedule.endTime).toBe(schedule.endTime);
+                expect(store.order.schedule.routeCode).toBe(schedule.routeCode);
+                expect(store.order.schedule.jobMaxMinutes).toBe(schedule.jobMaxMinutes);
+            });
+            it('sets expected remaining order data', async () => {
+                // Arrange
+                globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.resolve(fullApiResponse));
+                const originalWorkOrderNumber = store.order.workOrderNumber;
+
+                // Act
+                await store.loadSession();
+
+                // Asserts
+                expect(store.order.referralNumber).toBe(fullApiResponse.order.referralNumber);
+                expect(store.order.referralDate).toBe(fullApiResponse.order.referralDate);
+                expect(store.order.referralCorrelationId).toBe(fullApiResponse.order.referralCorrelationId);
+                expect(store.order.referralSequenceNumber).toBe(fullApiResponse.order.referralSequenceNumber);
+                expect(store.order.eon).toBe(fullApiResponse.order.eon);
+                expect(store.order.workOrderNumber).toBe(originalWorkOrderNumber);
+                expect(store.order.originalDeductible).toBe(policy.originalDeductible);
+                expect(store.order.currentDeductible).toBe(policy.currentDeductible);
+            });
+        });
+        it('api call throws exception', async () => {
+            expect.assertions(2);
+            const error = 'this is the error';
+            globalMethods.callHttpClient = jest.fn().mockReturnValue(Promise.reject(error));
+
+            // Act
+            await store.loadSession().catch((e) => {
+                expect(e).toEqual(error);
+            });
+
+            // Asserts
+            expect(globalMethods.callHttpClient)
+                .toHaveBeenCalledWith(expect.objectContaining({
+                    method: endpoints.LoadSession.method,
+                    endpoint: endpoints.LoadSession.url
+                }));
         });
     });