diff --git a/packages/compass-data-modeling/src/components/new-diagram-form.spec.tsx b/packages/compass-data-modeling/src/components/new-diagram-form.spec.tsx
new file mode 100644
index 00000000000..571c377db0c
--- /dev/null
+++ b/packages/compass-data-modeling/src/components/new-diagram-form.spec.tsx
@@ -0,0 +1,431 @@
+import React from 'react';
+import { expect } from 'chai';
+import {
+  screen,
+  userEvent,
+  waitFor,
+  within,
+} from '@mongodb-js/testing-library-compass';
+import NewDiagramForm from './new-diagram-form';
+import { changeName, createNewDiagram } from '../store/generate-diagram-wizard';
+import { renderWithStore } from '../../test/setup-store';
+import type { DataModelingStore } from '../../test/setup-store';
+
+describe('NewDiagramForm', function () {
+  context('enter-name step', function () {
+    let store: DataModelingStore;
+    let modal: HTMLElement;
+
+    beforeEach(() => {
+      const { store: setupStore } = renderWithStore(<NewDiagramForm />);
+      store = setupStore;
+      store.dispatch(createNewDiagram());
+      modal = screen.getByTestId('new-diagram-modal');
+      expect(modal).to.be.visible;
+    });
+
+    it('allows user to enter name for the model', function () {
+      userEvent.type(
+        within(modal).getByTestId('new-diagram-name-input'),
+        'diagram-1'
+      );
+      expect(store.getState().generateDiagramWizard.diagramName).to.equal(
+        'diagram-1'
+      );
+    });
+
+    it('keeps next button disabled if diagram name is empty', function () {
+      userEvent.clear(within(modal).getByTestId('new-diagram-name-input'));
+      expect(store.getState().generateDiagramWizard.diagramName).to.equal('');
+      const button = within(modal).getByRole('button', {
+        name: /next/i,
+      });
+      expect(button.getAttribute('aria-disabled')).to.equal('true');
+    });
+
+    it('cancels process when cancel is clicked', function () {
+      userEvent.click(
+        within(modal).getByRole('button', {
+          name: /cancel/i,
+        })
+      );
+      expect(store.getState().generateDiagramWizard.inProgress).to.be.false;
+    });
+  });
+
+  context('select-connection step', function () {
+    it('shows warning if there are no connections', function () {
+      const { store } = renderWithStore(<NewDiagramForm />, {
+        connections: [],
+      });
+      store.dispatch(createNewDiagram());
+
+      store.dispatch(changeName('diagram1'));
+      userEvent.click(
+        screen.getByRole('button', {
+          name: /next/i,
+        })
+      );
+
+      const alert = screen.getByRole('alert');
+      expect(alert.textContent).to.contain(
+        'You do not have any connections, create a new connection first'
+      );
+    });
+
+    it('shows list of connections and allows user to select one', async function () {
+      const { store } = renderWithStore(<NewDiagramForm />);
+
+      {
+        // Navigate to connections step
+        store.dispatch(createNewDiagram());
+        store.dispatch(changeName('diagram1'));
+        userEvent.click(
+          screen.getByRole('button', {
+            name: /next/i,
+          })
+        );
+      }
+
+      userEvent.click(screen.getByTestId('new-diagram-connection-selector'));
+      expect(screen.getByText('Conn1')).to.exist;
+      expect(screen.getByText('Conn2')).to.exist;
+
+      userEvent.click(screen.getByText('Conn2'));
+      expect(store.getState().generateDiagramWizard.selectedConnectionId).to.eq(
+        'two'
+      );
+
+      userEvent.click(
+        screen.getByRole('button', {
+          name: /next/i,
+        })
+      );
+
+      expect(store.getState().generateDiagramWizard.step).to.equal(
+        'CONNECTING'
+      );
+      await waitFor(() => {
+        expect(
+          store.getState().generateDiagramWizard.connectionDatabases
+        ).to.deep.equal(['berlin', 'sample_airbnb']);
+      });
+
+      expect(store.getState().generateDiagramWizard.step).to.equal(
+        'SELECT_DATABASE'
+      );
+    });
+
+    it('shows error if it fails to connect', async function () {
+      const { store } = renderWithStore(<NewDiagramForm />, {
+        services: {
+          connections: {
+            connect() {
+              throw new Error('Can not connect');
+            },
+            getConnectionById(id: string) {
+              return {
+                info: { id },
+              };
+            },
+          } as any,
+        },
+      });
+
+      {
+        // Navigate to connections step
+        store.dispatch(createNewDiagram());
+        store.dispatch(changeName('diagram1'));
+        userEvent.click(
+          screen.getByRole('button', {
+            name: /next/i,
+          })
+        );
+      }
+
+      userEvent.click(screen.getByTestId('new-diagram-connection-selector'));
+      userEvent.click(screen.getByText('Conn2'));
+      userEvent.click(
+        screen.getByRole('button', {
+          name: /next/i,
+        })
+      );
+
+      await waitFor(() => {
+        // As it fails to connect, we are closing the modal and the toast is shown
+        // to the user with an error (which is outside of this component).
+        expect(store.getState().generateDiagramWizard.inProgress).to.be.false;
+      });
+    });
+  });
+
+  context('select-database step', function () {
+    it('shows list of databases and allows user to select one', async function () {
+      const { store } = renderWithStore(<NewDiagramForm />);
+
+      {
+        // Navigate to connections step
+        store.dispatch(createNewDiagram());
+        store.dispatch(changeName('diagram1'));
+        userEvent.click(
+          screen.getByRole('button', {
+            name: /next/i,
+          })
+        );
+      }
+
+      {
+        // Navigate to select db
+        userEvent.click(screen.getByTestId('new-diagram-connection-selector'));
+        userEvent.click(screen.getByText('Conn2'));
+        userEvent.click(
+          screen.getByRole('button', {
+            name: /next/i,
+          })
+        );
+        await waitFor(() => {
+          expect(store.getState().generateDiagramWizard.step).to.equal(
+            'SELECT_DATABASE'
+          );
+        });
+      }
+
+      userEvent.click(screen.getByTestId('new-diagram-database-selector'));
+      expect(screen.getByText('berlin')).to.exist;
+      expect(screen.getByText('sample_airbnb')).to.exist;
+
+      userEvent.click(screen.getByText('sample_airbnb'));
+      expect(store.getState().generateDiagramWizard.selectedDatabase).to.eq(
+        'sample_airbnb'
+      );
+
+      userEvent.click(
+        screen.getByRole('button', {
+          name: /next/i,
+        })
+      );
+
+      expect(store.getState().generateDiagramWizard.step).to.equal(
+        'LOADING_COLLECTIONS'
+      );
+      await waitFor(() => {
+        expect(
+          store.getState().generateDiagramWizard.selectedCollections
+        ).to.deep.equal(['listings', 'listingsAndReviews', 'reviews']);
+      });
+
+      expect(store.getState().generateDiagramWizard.step).to.equal(
+        'SELECT_COLLECTIONS'
+      );
+    });
+
+    it('shows error if it fails to fetch list of databases', async function () {
+      const { store } = renderWithStore(<NewDiagramForm />, {
+        services: {
+          connections: {
+            connect() {
+              return Promise.resolve();
+            },
+            getConnectionById(id: string) {
+              return {
+                info: { id },
+              };
+            },
+            getDataServiceForConnection() {
+              return {
+                listDatabases() {
+                  throw new Error('Can not list databases');
+                },
+              };
+            },
+          } as any,
+        },
+      });
+
+      {
+        // Navigate to connections step
+        store.dispatch(createNewDiagram());
+        store.dispatch(changeName('diagram1'));
+        userEvent.click(
+          screen.getByRole('button', {
+            name: /next/i,
+          })
+        );
+      }
+
+      userEvent.click(screen.getByTestId('new-diagram-connection-selector'));
+      userEvent.click(screen.getByText('Conn2'));
+      userEvent.click(
+        screen.getByRole('button', {
+          name: /next/i,
+        })
+      );
+
+      await waitFor(() => {
+        expect(store.getState().generateDiagramWizard.step).to.equal(
+          'SELECT_DATABASE'
+        );
+      });
+
+      expect(screen.getByText(/select database/i)).to.exist;
+      expect(store.getState().generateDiagramWizard.error?.message).to.equal(
+        'Can not list databases'
+      );
+      const alert = screen.getByRole('alert');
+      expect(alert.textContent).to.contain('Can not list databases');
+    });
+  });
+
+  context('select-collections step', function () {
+    it('shows list of collections', async function () {
+      const { store } = renderWithStore(<NewDiagramForm />);
+
+      {
+        // Navigate to connections step
+        store.dispatch(createNewDiagram());
+        store.dispatch(changeName('diagram1'));
+        userEvent.click(
+          screen.getByRole('button', {
+            name: /next/i,
+          })
+        );
+      }
+
+      {
+        // Navigate to select db
+        userEvent.click(screen.getByTestId('new-diagram-connection-selector'));
+        userEvent.click(screen.getByText('Conn2'));
+        userEvent.click(
+          screen.getByRole('button', {
+            name: /next/i,
+          })
+        );
+        await waitFor(() => {
+          expect(store.getState().generateDiagramWizard.step).to.equal(
+            'SELECT_DATABASE'
+          );
+        });
+      }
+
+      {
+        // Navigate to select colls
+        userEvent.click(screen.getByTestId('new-diagram-database-selector'));
+        userEvent.click(screen.getByText('sample_airbnb'));
+        userEvent.click(
+          screen.getByRole('button', {
+            name: /next/i,
+          })
+        );
+        await waitFor(() => {
+          expect(store.getState().generateDiagramWizard.step).to.equal(
+            'SELECT_COLLECTIONS'
+          );
+        });
+      }
+
+      expect(screen.getByText('listings')).to.exist;
+      expect(screen.getByText('listingsAndReviews')).to.exist;
+      expect(screen.getByText('reviews')).to.exist;
+
+      expect(store.getState().generateDiagramWizard.step).to.equal(
+        'SELECT_COLLECTIONS'
+      );
+      expect(
+        store.getState().generateDiagramWizard.selectedCollections
+      ).to.deep.equal(['listings', 'listingsAndReviews', 'reviews']);
+
+      userEvent.click(
+        screen.getByRole('button', {
+          name: /generate/i,
+        })
+      );
+
+      await waitFor(() => {
+        expect(store.getState().generateDiagramWizard.inProgress).to.be.false;
+      });
+    });
+
+    it('shows error if it fails to fetch list of collections', async function () {
+      const { store } = renderWithStore(<NewDiagramForm />, {
+        services: {
+          connections: {
+            connect() {
+              return Promise.resolve();
+            },
+            getConnectionById(id: string) {
+              return {
+                info: { id },
+              };
+            },
+            getDataServiceForConnection() {
+              return {
+                listDatabases() {
+                  return [
+                    {
+                      _id: 'sample_airbnb',
+                      name: 'sample_airbnb',
+                    },
+                  ];
+                },
+                listCollections() {
+                  throw new Error('Can not list collections');
+                },
+              };
+            },
+          } as any,
+        },
+      });
+
+      {
+        // Navigate to connections step
+        store.dispatch(createNewDiagram());
+        store.dispatch(changeName('diagram1'));
+        userEvent.click(
+          screen.getByRole('button', {
+            name: /next/i,
+          })
+        );
+      }
+
+      {
+        // Navigate to databases list
+        userEvent.click(screen.getByTestId('new-diagram-connection-selector'));
+        userEvent.click(screen.getByText('Conn2'));
+        userEvent.click(
+          screen.getByRole('button', {
+            name: /next/i,
+          })
+        );
+        await waitFor(() => {
+          expect(store.getState().generateDiagramWizard.step).to.equal(
+            'SELECT_DATABASE'
+          );
+        });
+      }
+
+      {
+        // Navigate to collections
+        userEvent.click(screen.getByTestId('new-diagram-database-selector'));
+        userEvent.click(screen.getByText('sample_airbnb'));
+        userEvent.click(
+          screen.getByRole('button', {
+            name: /next/i,
+          })
+        );
+        // When it fails to load collections, we are back at SELECT_DATABASE
+        await waitFor(() => {
+          expect(store.getState().generateDiagramWizard.step).to.equal(
+            'SELECT_DATABASE'
+          );
+        });
+      }
+
+      expect(screen.getByText(/select database/i)).to.exist;
+      expect(store.getState().generateDiagramWizard.error?.message).to.equal(
+        'Can not list collections'
+      );
+      const alert = screen.getByRole('alert');
+      expect(alert.textContent).to.contain('Can not list collections');
+    });
+  });
+});
diff --git a/packages/compass-data-modeling/src/components/new-diagram-form.tsx b/packages/compass-data-modeling/src/components/new-diagram-form.tsx
index b4d90061433..bac68927711 100644
--- a/packages/compass-data-modeling/src/components/new-diagram-form.tsx
+++ b/packages/compass-data-modeling/src/components/new-diagram-form.tsx
@@ -21,6 +21,7 @@ import {
   Banner,
   Button,
   css,
+  ErrorSummary,
   FormFieldContainer,
   Modal,
   ModalBody,
@@ -29,9 +30,14 @@ import {
   Option,
   Select,
   SelectTable,
+  spacing,
   TextInput,
 } from '@mongodb-js/compass-components';
 
+const footerStyles = css({
+  gap: spacing[200],
+});
+
 const FormStepContainer: React.FunctionComponent<{
   title: string;
   description?: string;
@@ -56,7 +62,7 @@ const FormStepContainer: React.FunctionComponent<{
     <>
       <ModalHeader title={title} subtitle={description}></ModalHeader>
       <ModalBody>{children}</ModalBody>
-      <ModalFooter>
+      <ModalFooter className={footerStyles}>
         <Button
           onClick={onNextClick}
           disabled={isNextDisabled}
@@ -90,6 +96,7 @@ type NewDiagramFormProps = {
   selectedDatabase: string | null;
   collections: string[];
   selectedCollections: string[];
+  error: Error | null;
 
   onCancel: () => void;
   onNameChange: (name: string) => void;
@@ -115,6 +122,7 @@ const NewDiagramForm: React.FunctionComponent<NewDiagramFormProps> = ({
   selectedDatabase,
   collections,
   selectedCollections,
+  error,
   onCancel,
   onNameChange,
   onNameConfirm,
@@ -174,7 +182,7 @@ const NewDiagramForm: React.FunctionComponent<NewDiagramFormProps> = ({
           onConfirmAction: onCollectionsSelectionConfirm,
           confirmActionLabel: 'Generate',
           isConfirmDisabled:
-            !selectedCollections || selectCollections.length === 0,
+            !selectedCollections || selectedCollections.length === 0,
           onCancelAction: onDatabaseSelectCancel,
           cancelLabel: 'Back',
         };
@@ -203,7 +211,7 @@ const NewDiagramForm: React.FunctionComponent<NewDiagramFormProps> = ({
             <TextInput
               label="New data model name"
               value={diagramName}
-              data-testId="new-diagram-name-input"
+              data-testid="new-diagram-name-input"
               onChange={(e) => {
                 onNameChange(e.currentTarget.value);
               }}
@@ -215,6 +223,7 @@ const NewDiagramForm: React.FunctionComponent<NewDiagramFormProps> = ({
           <FormFieldContainer>
             <Select
               label=""
+              aria-label="Select connection"
               value={selectedConnectionId ?? ''}
               data-testid="new-diagram-connection-selector"
               onChange={onConnectionSelect}
@@ -240,6 +249,7 @@ const NewDiagramForm: React.FunctionComponent<NewDiagramFormProps> = ({
           <FormFieldContainer>
             <Select
               label=""
+              aria-label="Select database"
               value={selectedDatabase ?? ''}
               data-testid="new-diagram-database-selector"
               onChange={onDatabaseSelect}
@@ -317,6 +327,7 @@ const NewDiagramForm: React.FunctionComponent<NewDiagramFormProps> = ({
         isLoading={isLoading}
       >
         {formContent}
+        {error && <ErrorSummary errors={[error.message]} />}
       </FormStepContainer>
     </Modal>
   );
@@ -351,6 +362,7 @@ export default connect(
       selectedDatabase,
       databaseCollections,
       selectedCollections,
+      error,
     } = state.generateDiagramWizard;
     return {
       isModalOpen: inProgress,
@@ -366,6 +378,7 @@ export default connect(
       selectedDatabase,
       collections: databaseCollections ?? [],
       selectedCollections: selectedCollections ?? [],
+      error,
     };
   },
   {
diff --git a/packages/compass-data-modeling/src/index.ts b/packages/compass-data-modeling/src/index.ts
index f58cdd6da0e..a9f5f0c5fda 100644
--- a/packages/compass-data-modeling/src/index.ts
+++ b/packages/compass-data-modeling/src/index.ts
@@ -1,5 +1,3 @@
-import { applyMiddleware, createStore } from 'redux';
-import thunk from 'redux-thunk';
 import { registerHadronPlugin } from 'hadron-app-registry';
 import { preferencesLocator } from 'compass-preferences-model/provider';
 import { connectionsLocator } from '@mongodb-js/compass-connections/provider';
@@ -7,24 +5,15 @@ import { telemetryLocator } from '@mongodb-js/compass-telemetry/provider';
 import { createLoggerLocator } from '@mongodb-js/compass-logging/provider';
 import type { WorkspaceComponent } from '@mongodb-js/compass-workspaces';
 import DataModelingComponent from './components/data-modeling';
-import reducer from './store/reducer';
 import { mongoDBInstancesManagerLocator } from '@mongodb-js/compass-app-stores/provider';
 import { dataModelStorageServiceLocator } from './provider';
+import { activateDataModelingStore } from './store';
 
 const DataModelingPlugin = registerHadronPlugin(
   {
     name: 'DataModeling',
     component: DataModelingComponent,
-    activate(initialProps, services, { cleanup }) {
-      const cancelControllerRef = { current: null };
-      const store = createStore(
-        reducer,
-        applyMiddleware(
-          thunk.withExtraArgument({ ...services, cancelControllerRef })
-        )
-      );
-      return { store, deactivate: cleanup };
-    },
+    activate: activateDataModelingStore,
   },
   {
     preferences: preferencesLocator,
diff --git a/packages/compass-data-modeling/src/provider/index.tsx b/packages/compass-data-modeling/src/provider/index.tsx
index a545bbc71e2..716756627a9 100644
--- a/packages/compass-data-modeling/src/provider/index.tsx
+++ b/packages/compass-data-modeling/src/provider/index.tsx
@@ -11,7 +11,7 @@ type DataModelStorageServiceState = {
   items: MongoDBDataModelDescription[];
 };
 
-const noopDataModelStorageService: DataModelStorageServiceState &
+export const noopDataModelStorageService: DataModelStorageServiceState &
   DataModelStorage = {
   status: 'INITIAL',
   error: null,
diff --git a/packages/compass-data-modeling/src/store/analysis-process.ts b/packages/compass-data-modeling/src/store/analysis-process.ts
index e8ffc9da387..faf96e90ed0 100644
--- a/packages/compass-data-modeling/src/store/analysis-process.ts
+++ b/packages/compass-data-modeling/src/store/analysis-process.ts
@@ -209,6 +209,12 @@ export function startAnalysis(
       if (cancelController.signal.aborted) {
         dispatch({ type: AnalysisProcessActionTypes.ANALYSIS_CANCELED });
       } else {
+        services.logger.log.error(
+          services.logger.mongoLogId(1_001_000_350),
+          'DataModeling',
+          'Failed to analyze schema',
+          { err }
+        );
         dispatch({
           type: AnalysisProcessActionTypes.ANALYSIS_FAILED,
           error: err as Error,
diff --git a/packages/compass-data-modeling/src/store/generate-diagram-wizard.ts b/packages/compass-data-modeling/src/store/generate-diagram-wizard.ts
index 5f6b9faff70..9e992925577 100644
--- a/packages/compass-data-modeling/src/store/generate-diagram-wizard.ts
+++ b/packages/compass-data-modeling/src/store/generate-diagram-wizard.ts
@@ -23,6 +23,7 @@ export type GenerateDiagramWizardState = {
   databaseCollections: string[] | null;
   selectedCollections: string[] | null;
   automaticallyInferRelations: boolean;
+  error: Error | null;
 };
 
 export enum GenerateDiagramWizardActionTypes {
@@ -42,6 +43,7 @@ export enum GenerateDiagramWizardActionTypes {
 
   SELECT_DATABASE = 'data-modeling/generate-diagram-wizard/SELECT_DATABASE',
   CONFIRM_SELECT_DATABASE = 'data-modeling/generate-diagram-wizard/CONFIRM_SELECT_DATABASE',
+  DATABASES_FETCH_FAILED = 'data-modeling/generate-diagram-wizard/DATABASES_FETCH_FAILED',
   COLLECTIONS_FETCHED = 'data-modeling/generate-diagram-wizard/COLLECTIONS_FETCHED',
   CANCEL_SELECTED_DATABASE = 'data-modeling/generate-diagram-wizard/CANCEL_SELECTED_DATABASE',
   COLLECTIONS_FETCH_FAILED = 'data-modeling/generate-diagram-wizard/COLLECTIONS_FETCH_FAILED',
@@ -104,6 +106,11 @@ export type SelectDatabaseAction = {
   database: string;
 };
 
+export type DatabasesFetchFailedAction = {
+  type: GenerateDiagramWizardActionTypes.DATABASES_FETCH_FAILED;
+  error: Error;
+};
+
 export type ConfirmSelectDatabaseAction = {
   type: GenerateDiagramWizardActionTypes.CONFIRM_SELECT_DATABASE;
 };
@@ -121,6 +128,7 @@ export type CollectionsFetchedAction = {
 
 export type CollectionsFetchFailedAction = {
   type: GenerateDiagramWizardActionTypes.COLLECTIONS_FETCH_FAILED;
+  error: Error;
 };
 
 export type SelectCollectionsAction = {
@@ -147,17 +155,21 @@ export type GenerateDiagramWizardActions =
   | DatabasesFetchedAction
   | SelectDatabaseAction
   | ConfirmSelectDatabaseAction
+  | DatabasesFetchFailedAction
   | CancelSelectedDatabaseAction
   | CollectionsFetchedAction
   | SelectCollectionsAction
   | ToggleInferRelationsAction
-  | ConfirmSelectedCollectionsAction;
+  | ConfirmSelectedCollectionsAction
+  | CollectionsFetchFailedAction
+  | ConnectionFailedAction;
 
 const INITIAL_STATE: GenerateDiagramWizardState = {
   inProgress: false,
   step: 'ENTER_NAME',
   diagramName: '',
   selectedConnectionId: null,
+  error: null,
   connectionDatabases: null,
   selectedDatabase: null,
   databaseCollections: null,
@@ -186,6 +198,7 @@ export const generateDiagramWizardReducer: Reducer<
   if (isAction(action, GenerateDiagramWizardActionTypes.CANCEL_CONFIRM_NAME)) {
     return {
       ...state,
+      error: null,
       step: 'ENTER_NAME',
     };
   }
@@ -193,6 +206,7 @@ export const generateDiagramWizardReducer: Reducer<
     return {
       ...state,
       selectedConnectionId: action.id,
+      error: null,
     };
   }
   if (
@@ -220,6 +234,15 @@ export const generateDiagramWizardReducer: Reducer<
       selectedDatabase: null,
     };
   }
+  if (
+    isAction(action, GenerateDiagramWizardActionTypes.DATABASES_FETCH_FAILED)
+  ) {
+    return {
+      ...state,
+      step: 'SELECT_DATABASE',
+      error: action.error,
+    };
+  }
   if (isAction(action, GenerateDiagramWizardActionTypes.SELECT_DATABASE)) {
     return {
       ...state,
@@ -295,7 +318,16 @@ export const generateDiagramWizardReducer: Reducer<
   ) {
     return {
       ...state,
-      inProgress: false,
+      error: action.error,
+      step: 'SELECT_DATABASE',
+    };
+  }
+  if (
+    isAction(action, GenerateDiagramWizardActionTypes.CONFIRM_SELECT_DATABASE)
+  ) {
+    return {
+      ...state,
+      step: 'LOADING_COLLECTIONS',
     };
   }
   return state;
@@ -326,22 +358,45 @@ export function confirmSelectConnection(): DataModelingThunkAction<
   | ConnectionConnectedAction
   | DatabasesFetchedAction
   | ConnectionFailedAction
+  | DatabasesFetchFailedAction
 > {
   return async (dispatch, getState, services) => {
     dispatch({
       type: GenerateDiagramWizardActionTypes.CONFIRM_SELECT_CONNECTION,
     });
+
+    const { selectedConnectionId } = getState().generateDiagramWizard;
+    if (!selectedConnectionId) {
+      return;
+    }
     try {
-      const { selectedConnectionId } = getState().generateDiagramWizard;
-      if (!selectedConnectionId) {
-        return;
-      }
       const connectionInfo =
         services.connections.getConnectionById(selectedConnectionId)?.info;
       if (!connectionInfo) {
         return;
       }
       await services.connections.connect(connectionInfo);
+      // ConnectionsService.connect does not throw an error if it fails to establish a connection,
+      // so explicitly checking if error is in the connection item and throwing it.
+      const connectionError =
+        services.connections.getConnectionById(selectedConnectionId)?.error;
+      if (connectionError) {
+        throw connectionError;
+      }
+    } catch (err) {
+      services.logger.log.error(
+        services.logger.mongoLogId(1_001_000_348),
+        'DataModeling',
+        'Failed to select connection',
+        { err }
+      );
+      dispatch({
+        type: GenerateDiagramWizardActionTypes.CONNECTION_FAILED,
+      });
+      return;
+    }
+
+    try {
       dispatch({ type: GenerateDiagramWizardActionTypes.CONNECTION_CONNECTED });
       const mongoDBInstance =
         services.instanceManager.getMongoDBInstanceForConnection(
@@ -362,7 +417,16 @@ export function confirmSelectConnection(): DataModelingThunkAction<
           }),
       });
     } catch (err) {
-      dispatch({ type: GenerateDiagramWizardActionTypes.CONNECTION_FAILED });
+      services.logger.log.error(
+        services.logger.mongoLogId(1_001_000_351),
+        'DataModeling',
+        'Failed to list databases',
+        { err }
+      );
+      dispatch({
+        type: GenerateDiagramWizardActionTypes.DATABASES_FETCH_FAILED,
+        error: err as Error,
+      });
     }
   };
 }
@@ -414,8 +478,15 @@ export function confirmSelectDatabase(): DataModelingThunkAction<
           }),
       });
     } catch (err) {
+      services.logger.log.error(
+        services.logger.mongoLogId(1_001_000_349),
+        'DataModeling',
+        'Failed to select database',
+        { err }
+      );
       dispatch({
         type: GenerateDiagramWizardActionTypes.COLLECTIONS_FETCH_FAILED,
+        error: err as Error,
       });
     }
   };
diff --git a/packages/compass-data-modeling/src/store/index.ts b/packages/compass-data-modeling/src/store/index.ts
new file mode 100644
index 00000000000..2457a9e49de
--- /dev/null
+++ b/packages/compass-data-modeling/src/store/index.ts
@@ -0,0 +1,36 @@
+import type { PreferencesAccess } from 'compass-preferences-model/provider';
+import type { ConnectionsService } from '@mongodb-js/compass-connections/provider';
+import type { TrackFunction } from '@mongodb-js/compass-telemetry/provider';
+import type { Logger } from '@mongodb-js/compass-logging/provider';
+import type { MongoDBInstancesManager } from '@mongodb-js/compass-app-stores/provider';
+import type { DataModelStorageService } from '../provider';
+import { applyMiddleware, createStore } from 'redux';
+import reducer from './reducer';
+import thunk from 'redux-thunk';
+import type { ActivateHelpers } from 'hadron-app-registry';
+
+export type DataModelingStoreOptions = Record<string, unknown>;
+
+export type DataModelingStoreServices = {
+  preferences: PreferencesAccess;
+  connections: ConnectionsService;
+  instanceManager: MongoDBInstancesManager;
+  dataModelStorage: DataModelStorageService;
+  track: TrackFunction;
+  logger: Logger;
+};
+
+export function activateDataModelingStore(
+  _: DataModelingStoreOptions,
+  services: DataModelingStoreServices,
+  { cleanup }: ActivateHelpers
+) {
+  const cancelControllerRef = { current: null };
+  const store = createStore(
+    reducer,
+    applyMiddleware(
+      thunk.withExtraArgument({ ...services, cancelControllerRef })
+    )
+  );
+  return { store, deactivate: cleanup };
+}
diff --git a/packages/compass-data-modeling/src/store/reducer.ts b/packages/compass-data-modeling/src/store/reducer.ts
index ef499c4dbbb..dddc09fac0f 100644
--- a/packages/compass-data-modeling/src/store/reducer.ts
+++ b/packages/compass-data-modeling/src/store/reducer.ts
@@ -13,13 +13,8 @@ import { analysisProcessReducer } from './analysis-process';
 import type { DiagramActions, DiagramActionTypes } from './diagram';
 import { diagramReducer } from './diagram';
 import type { ThunkAction } from 'redux-thunk';
-import type { PreferencesAccess } from 'compass-preferences-model/provider';
-import type { ConnectionsService } from '@mongodb-js/compass-connections/provider';
-import type { TrackFunction } from '@mongodb-js/compass-telemetry/provider';
-import type { Logger } from '@mongodb-js/compass-logging/provider';
-import type { MongoDBInstancesManager } from '@mongodb-js/compass-app-stores/provider';
 import { stepReducer } from './step';
-import type { DataModelStorageService } from '../provider';
+import type { DataModelingStoreServices } from '.';
 
 const reducer = combineReducers({
   step: stepReducer,
@@ -40,18 +35,14 @@ export type DataModelingActionTypes =
 
 export type DataModelingState = ReturnType<typeof reducer>;
 
+export type DataModelingExtraArgs = DataModelingStoreServices & {
+  cancelControllerRef: { current: AbortController | null };
+};
+
 export type DataModelingThunkAction<R, A extends AnyAction> = ThunkAction<
   R,
   DataModelingState,
-  {
-    preferences: PreferencesAccess;
-    connections: ConnectionsService;
-    instanceManager: MongoDBInstancesManager;
-    dataModelStorage: DataModelStorageService;
-    track: TrackFunction;
-    logger: Logger;
-    cancelControllerRef: { current: AbortController | null };
-  },
+  DataModelingExtraArgs,
   A
 >;
 
diff --git a/packages/compass-data-modeling/test/setup-store.tsx b/packages/compass-data-modeling/test/setup-store.tsx
new file mode 100644
index 00000000000..270f5874233
--- /dev/null
+++ b/packages/compass-data-modeling/test/setup-store.tsx
@@ -0,0 +1,199 @@
+import React from 'react';
+import { renderWithConnections } from '@mongodb-js/testing-library-compass';
+import { createActivateHelpers } from 'hadron-app-registry';
+import { createNoopTrack } from '@mongodb-js/compass-telemetry/provider';
+import { createNoopLogger } from '@mongodb-js/compass-logging/provider';
+import { TestMongoDBInstanceManager } from '@mongodb-js/compass-app-stores/provider';
+import type { ConnectionInfo } from '@mongodb-js/compass-connections/provider';
+import { activateDataModelingStore } from '../src/store';
+import type { DataModelingStoreServices } from '../src/store';
+import { noopDataModelStorageService } from '../src/provider';
+import { Provider } from 'react-redux';
+
+type ConnectionInfoWithMockData = ConnectionInfo & {
+  databases: Array<{
+    _id: string;
+    name: string;
+    collectionsStatus: string;
+    collectionsLength: number;
+    collections: Array<{
+      _id: string;
+      name: string;
+      type: string;
+      sourceName: string;
+    }>;
+  }>;
+};
+
+export type DataModelingStore = Awaited<ReturnType<typeof setupStore>>;
+const testConnections = [
+  {
+    id: 'one',
+    savedConnectionType: 'favorite' as const,
+    favorite: {
+      name: 'Conn1',
+    },
+    connectionOptions: {
+      connectionString: 'mongodb://localhost:27020/test',
+    },
+    databases: [
+      {
+        _id: 'db_initial',
+        name: 'db_initial',
+        collectionsStatus: 'initial',
+        collectionsLength: 0,
+        collections: [],
+      },
+      {
+        _id: 'db_ready',
+        name: 'db_ready',
+        collectionsStatus: 'ready',
+        collectionsLength: 3,
+        collections: [
+          {
+            _id: 'db_ready.meow',
+            name: 'meow',
+            type: 'collection',
+            sourceName: '',
+            pipeline: [],
+          },
+          {
+            _id: 'db_ready.woof',
+            name: 'woof',
+            type: 'timeseries',
+            sourceName: '',
+            pipeline: [],
+          },
+          {
+            _id: 'db_ready.bwok',
+            name: 'bwok',
+            type: 'view',
+            sourceName: '',
+            pipeline: [],
+          },
+        ],
+      },
+    ],
+  },
+  {
+    id: 'two',
+    savedConnectionType: 'recent' as const,
+    favorite: {
+      name: 'Conn2',
+    },
+    connectionOptions: {
+      connectionString: 'mongodb://localhost:27021/test',
+    },
+    databases: [
+      {
+        _id: 'berlin',
+        name: 'berlin',
+        collectionsStatus: 'initial',
+        collectionsLength: 1,
+        collections: [
+          {
+            _id: 'berlin.parks',
+            name: 'parks',
+            type: 'collection',
+            sourceName: '',
+            pipeline: [],
+          },
+        ],
+      },
+      {
+        _id: 'sample_airbnb',
+        name: 'sample_airbnb',
+        collectionsStatus: 'ready',
+        collectionsLength: 3,
+        collections: [
+          {
+            _id: 'sample_airbnb.listings',
+            name: 'listings',
+            type: 'collection',
+            sourceName: '',
+            pipeline: [],
+          },
+          {
+            _id: 'sample_airbnb.reviews',
+            name: 'reviews',
+            type: 'collection',
+            sourceName: '',
+            pipeline: [],
+          },
+          {
+            _id: 'sample_airbnb.listingsAndReviews',
+            name: 'listingsAndReviews',
+            type: 'view',
+            sourceName: 'listings',
+            pipeline: [],
+          },
+        ],
+      },
+    ],
+  },
+];
+
+export const setupStore = (
+  services: Partial<DataModelingStoreServices> = {},
+  connections: ConnectionInfoWithMockData[] = testConnections
+) => {
+  return activateDataModelingStore(
+    {},
+    {
+      logger: createNoopLogger('TEST'),
+      track: createNoopTrack(),
+      connections: {
+        connect() {
+          return Promise.resolve();
+        },
+        getConnectionById(connId: string) {
+          const conn = connections.find((x) => x.id === connId);
+          if (!conn) {
+            return undefined;
+          }
+          return {
+            info: connections.find((x) => x.id === connId),
+          };
+        },
+        getDataServiceForConnection(connId: string) {
+          const conn = connections.find((x) => x.id === connId);
+          if (!conn) {
+            throw new Error('No available connection');
+          }
+          return {
+            listDatabases: () => {
+              return Promise.resolve(conn.databases);
+            },
+            listCollections: (database: string) => {
+              return Promise.resolve(
+                conn.databases.find((x) => x._id === database)?.collections
+              );
+            },
+          };
+        },
+      } as any,
+      preferences: {} as any,
+      instanceManager: new TestMongoDBInstanceManager(),
+      dataModelStorage: noopDataModelStorageService,
+      ...services,
+    },
+    createActivateHelpers()
+  ).store;
+};
+export const renderWithStore = (
+  component: JSX.Element,
+  {
+    services = {},
+    connections = testConnections,
+  }: {
+    services?: Partial<DataModelingStoreServices>;
+    connections?: ConnectionInfoWithMockData[];
+  } = {}
+) => {
+  const store = setupStore(services, connections);
+  const renderResult = renderWithConnections(
+    <Provider store={store}>{component}</Provider>,
+    { connections }
+  );
+  return { ...renderResult, store };
+};