diff --git a/.changeset/descendants-exports.md b/.changeset/descendants-exports.md
new file mode 100644
index 0000000000..dc9167bd65
--- /dev/null
+++ b/.changeset/descendants-exports.md
@@ -0,0 +1,5 @@
+---
+'@leafygreen-ui/descendants': minor
+---
+
+Exports `Position` enum. Removes type annotation from `Direction` export
diff --git a/.changeset/form-footer-interfaces.md b/.changeset/form-footer-interfaces.md
new file mode 100644
index 0000000000..5012b2b263
--- /dev/null
+++ b/.changeset/form-footer-interfaces.md
@@ -0,0 +1,5 @@
+---
+'@leafygreen-ui/form-footer': minor
+---
+
+Exports button prop interfaces
diff --git a/.changeset/form-footer-lgids.md b/.changeset/form-footer-lgids.md
new file mode 100644
index 0000000000..df3b330741
--- /dev/null
+++ b/.changeset/form-footer-lgids.md
@@ -0,0 +1,5 @@
+---
+'@leafygreen-ui/form-footer': patch
+---
+
+Passes `data-lgid` to the root `footer` element
diff --git a/.changeset/lib-find-children.md b/.changeset/lib-find-children.md
new file mode 100644
index 0000000000..7c0127e7d5
--- /dev/null
+++ b/.changeset/lib-find-children.md
@@ -0,0 +1,5 @@
+---
+'@leafygreen-ui/lib': minor
+---
+
+Adds `findChildren` utility to `lib`. Also adds `unwrapRootFragment` and `isChildWithProperty` helpers
diff --git a/.changeset/wizard.md b/.changeset/wizard.md
new file mode 100644
index 0000000000..43a87b291f
--- /dev/null
+++ b/.changeset/wizard.md
@@ -0,0 +1,7 @@
+---
+'@leafygreen-ui/wizard': minor
+---
+
+Initial Wizard package release.
+
+See [README.md](./README.md) for usage guidelines
\ No newline at end of file
diff --git a/packages/descendants/src/Highlight/index.ts b/packages/descendants/src/Highlight/index.ts
index 32c2e6536f..0ac8e5e878 100644
--- a/packages/descendants/src/Highlight/index.ts
+++ b/packages/descendants/src/Highlight/index.ts
@@ -1,10 +1,11 @@
-export type {
+export {
   Direction,
-  HighlightChangeHandler,
-  HighlightContextProps,
-  HighlightHookReturnType,
-  Index,
-  UseHighlightOptions,
+  type HighlightChangeHandler,
+  type HighlightContextProps,
+  type HighlightHookReturnType,
+  type Index,
+  Position,
+  type UseHighlightOptions,
 } from './highlight.types';
 export {
   createHighlightContext,
diff --git a/packages/descendants/src/index.ts b/packages/descendants/src/index.ts
index c5c6aada04..5f722dab2b 100644
--- a/packages/descendants/src/index.ts
+++ b/packages/descendants/src/index.ts
@@ -15,13 +15,14 @@ export {
 // Highlight
 export {
   createHighlightContext,
-  type Direction,
+  Direction,
   type HighlightChangeHandler,
   type HighlightContextProps,
   type HighlightContextType,
   type HighlightHookReturnType,
   HighlightProvider,
   type Index,
+  Position,
   useHighlight,
   useHighlightContext,
   type UseHighlightOptions,
diff --git a/packages/form-footer/src/FormFooter.tsx b/packages/form-footer/src/FormFooter.tsx
index 390583b014..91aab13658 100644
--- a/packages/form-footer/src/FormFooter.tsx
+++ b/packages/form-footer/src/FormFooter.tsx
@@ -47,6 +47,7 @@ export default function FormFooter({
     <LeafyGreenProvider darkMode={darkMode}>
       <footer
         data-testid={lgIds.root}
+        data-lgid={lgIds.root}
         className={getFormFooterStyles({ theme, className })}
         {...rest}
       >
diff --git a/packages/form-footer/src/FormFooter.types.ts b/packages/form-footer/src/FormFooter.types.ts
index ae516c4387..8ea2f29de3 100644
--- a/packages/form-footer/src/FormFooter.types.ts
+++ b/packages/form-footer/src/FormFooter.types.ts
@@ -20,26 +20,30 @@ type OmittedSplitButtonProps = Omit<
   'children' | 'variant'
 >;
 
-type BackStandardButtonProps = ButtonPropsOmittingVariant & {
+export type BackStandardButtonProps = ButtonPropsOmittingVariant & {
   variant?: Extract<ButtonVariant, 'default' | 'dangerOutline'>;
 };
-type BackSplitButtonProps = OmittedSplitButtonProps & {
+export type BackSplitButtonProps = OmittedSplitButtonProps & {
   variant?: Extract<SplitButtonVariant, 'default' | 'danger'>;
 };
-type BackButtonProps = BackStandardButtonProps | BackSplitButtonProps;
+export type BackButtonProps = BackStandardButtonProps | BackSplitButtonProps;
 
-type CancelStandardButtonProps = ButtonPropsOmittingVariant;
-type CancelSplitButtonProps = OmittedSplitButtonProps;
-type CancelButtonProps = CancelStandardButtonProps | CancelSplitButtonProps;
+export type CancelStandardButtonProps = ButtonPropsOmittingVariant;
+export type CancelSplitButtonProps = OmittedSplitButtonProps;
+export type CancelButtonProps =
+  | CancelStandardButtonProps
+  | CancelSplitButtonProps;
 
-type PrimaryStandardButtonProps = ButtonPropsOmittingVariant &
+export type PrimaryStandardButtonProps = ButtonPropsOmittingVariant &
   ButtonPropsWithRequiredChildren & {
     variant?: Extract<ButtonVariant, 'primary' | 'danger'>;
   };
-type PrimarySplitButtonProps = OmittedSplitButtonProps & {
+export type PrimarySplitButtonProps = OmittedSplitButtonProps & {
   variant?: Extract<SplitButtonVariant, 'primary' | 'danger'>;
 };
-type PrimaryButtonProps = PrimaryStandardButtonProps | PrimarySplitButtonProps;
+export type PrimaryButtonProps =
+  | PrimaryStandardButtonProps
+  | PrimarySplitButtonProps;
 
 export interface FormFooterProps
   extends React.ComponentProps<'footer'>,
diff --git a/packages/form-footer/src/index.ts b/packages/form-footer/src/index.ts
index e78a13d456..86271bbc7c 100644
--- a/packages/form-footer/src/index.ts
+++ b/packages/form-footer/src/index.ts
@@ -5,5 +5,16 @@ export {
   default,
   default as FormFooter,
 } from './FormFooter';
-export { type FormFooterProps } from './FormFooter.types';
+export {
+  type BackButtonProps,
+  type BackSplitButtonProps,
+  type BackStandardButtonProps,
+  type CancelButtonProps,
+  type CancelSplitButtonProps,
+  type CancelStandardButtonProps,
+  type FormFooterProps,
+  type PrimaryButtonProps,
+  type PrimarySplitButtonProps,
+  type PrimaryStandardButtonProps,
+} from './FormFooter.types';
 export { getLgIds } from './utils';
diff --git a/packages/lib/src/childQueries/findChild/findChild.spec.tsx b/packages/lib/src/childQueries/findChild/findChild.spec.tsx
index c322277615..fb902c7c5c 100644
--- a/packages/lib/src/childQueries/findChild/findChild.spec.tsx
+++ b/packages/lib/src/childQueries/findChild/findChild.spec.tsx
@@ -30,7 +30,7 @@ Baz.displayName = 'Baz';
 (Bar as any).isBar = true;
 (Baz as any).isBaz = true;
 
-describe('packages/lib/findChild', () => {
+describe('packages/compound-component/findChild', () => {
   test('should find a child component with matching static property', () => {
     // Create an iterable to test different iteration scenarios
     const children = [<Foo text="Foo" />, <Bar text="Bar" />];
@@ -77,6 +77,30 @@ describe('packages/lib/findChild', () => {
     expect((found as React.ReactElement).props.text).toBe('also-in-fragment');
   });
 
+  test('should find mapped children', () => {
+    const COUNT = 5;
+    const children = new Array(COUNT).fill(null).map((_, i) => {
+      return <Foo text={`Foo number ${i}`} />;
+    });
+
+    const found = findChild(children, 'isFoo');
+    expect((found as React.ReactElement).props.text).toBe('Foo number 0');
+  });
+
+  test('should find deeply mapped children', () => {
+    const COUNT = 5;
+    const children = (
+      <>
+        {new Array(COUNT).fill(null).map((_, i) => {
+          return <Foo text={`Foo number ${i}`} />;
+        })}
+      </>
+    );
+
+    const found = findChild(children, 'isFoo');
+    expect((found as React.ReactElement).props.text).toBe('Foo number 0');
+  });
+
   test('should NOT find components in deeply nested fragments (search depth limitation)', () => {
     const children = (
       <React.Fragment>
diff --git a/packages/lib/src/childQueries/findChild/findChild.tsx b/packages/lib/src/childQueries/findChild/findChild.tsx
index 26e552cf54..5c7a8e9b1c 100644
--- a/packages/lib/src/childQueries/findChild/findChild.tsx
+++ b/packages/lib/src/childQueries/findChild/findChild.tsx
@@ -42,8 +42,9 @@ export const findChild = (
   }
 
   const allChildren = unwrapRootFragment(children);
+  if (!allChildren) return;
 
-  return allChildren?.find(child =>
-    isChildWithProperty(child, staticProperty),
-  ) as ReactElement | undefined;
+  return allChildren
+    .flat()
+    .find(child => isChildWithProperty(child, staticProperty)) as ReactElement;
 };
diff --git a/packages/lib/src/childQueries/findChildren/findChildren.spec.tsx b/packages/lib/src/childQueries/findChildren/findChildren.spec.tsx
index 6327c51f63..023ae7c7df 100644
--- a/packages/lib/src/childQueries/findChildren/findChildren.spec.tsx
+++ b/packages/lib/src/childQueries/findChildren/findChildren.spec.tsx
@@ -30,7 +30,7 @@ Baz.displayName = 'Baz';
 (Bar as any).isBar = true;
 (Baz as any).isBaz = true;
 
-describe('packages/lib/findChildren', () => {
+describe('packages/compound-component/findChildren', () => {
   describe('basic functionality', () => {
     it('should find all children with matching static property', () => {
       const children = [
@@ -67,120 +67,142 @@ describe('packages/lib/findChildren', () => {
     });
   });
 
-  describe('empty and null children handling', () => {
-    it('should handle null children', () => {
-      const found = findChildren(null, 'isFoo');
-      expect(found).toEqual([]);
+  it('should find mapped children', () => {
+    const COUNT = 5;
+    const children = new Array(COUNT).fill(null).map((_, i) => {
+      return <Foo text={`Foo number ${i}`} />;
     });
 
-    it('should handle undefined children', () => {
-      const found = findChildren(undefined, 'isFoo');
-      expect(found).toEqual([]);
-    });
+    const found = findChildren(children, 'isFoo');
+    expect(found).toHaveLength(COUNT);
+  });
 
-    it('should handle empty fragment', () => {
-      const children = <></>;
-      const found = findChildren(children, 'isFoo');
-      expect(found).toEqual([]);
-    });
+  it('should find deeply mapped children', () => {
+    const COUNT = 5;
+    const children = (
+      <>
+        {new Array(COUNT).fill(null).map((_, i) => {
+          return <Foo text={`Foo number ${i}`} />;
+        })}
+      </>
+    );
+
+    const found = findChildren(children, 'isFoo');
+    expect(found).toHaveLength(COUNT);
+  });
+});
 
-    it('should handle empty array children', () => {
-      const children: Array<React.ReactElement> = [];
-      const found = findChildren(children, 'isFoo');
-      expect(found).toEqual([]);
-    });
+describe('empty and null children handling', () => {
+  it('should handle null children', () => {
+    const found = findChildren(null, 'isFoo');
+    expect(found).toEqual([]);
   });
 
-  describe('Fragment handling', () => {
-    it('should handle single-level fragment children', () => {
-      const children = (
-        <React.Fragment>
-          <Foo text="foo-in-fragment" />
-          <Bar text="bar-in-fragment" />
-          <Foo text="another-foo" />
-        </React.Fragment>
-      );
+  it('should handle undefined children', () => {
+    const found = findChildren(undefined, 'isFoo');
+    expect(found).toEqual([]);
+  });
 
-      const found = findChildren(children, 'isFoo');
-      expect(found).toHaveLength(2);
-      expect(found[0].props.text).toBe('foo-in-fragment');
-      expect(found[1].props.text).toBe('another-foo');
-    });
+  it('should handle empty fragment', () => {
+    const children = <></>;
+    const found = findChildren(children, 'isFoo');
+    expect(found).toEqual([]);
+  });
+
+  it('should handle empty array children', () => {
+    const children: Array<React.ReactElement> = [];
+    const found = findChildren(children, 'isFoo');
+    expect(found).toEqual([]);
+  });
+});
 
-    it('should NOT find children in deeply nested Fragments', () => {
-      const children = (
+describe('Fragment handling', () => {
+  it('should handle single-level fragment children', () => {
+    const children = (
+      <React.Fragment>
+        <Foo text="foo-in-fragment" />
+        <Bar text="bar-in-fragment" />
+        <Foo text="another-foo" />
+      </React.Fragment>
+    );
+
+    const found = findChildren(children, 'isFoo');
+    expect(found).toHaveLength(2);
+    expect(found[0].props.text).toBe('foo-in-fragment');
+    expect(found[1].props.text).toBe('another-foo');
+  });
+
+  it('should NOT find children in deeply nested Fragments', () => {
+    const children = (
+      <React.Fragment>
+        <Foo text="direct-foo" />
         <React.Fragment>
-          <Foo text="direct-foo" />
           <React.Fragment>
-            <React.Fragment>
-              <Foo text="deeply-nested-foo" />
-            </React.Fragment>
+            <Foo text="deeply-nested-foo" />
           </React.Fragment>
-          <Bar text="direct-bar" />
         </React.Fragment>
-      );
-
-      // Should only find direct children, not double-nested ones
-      const found = findChildren(children, 'isFoo');
-      expect(found).toHaveLength(1);
-      expect(found[0].props.text).toBe('direct-foo');
-    });
+        <Bar text="direct-bar" />
+      </React.Fragment>
+    );
+
+    // Should only find direct children, not double-nested ones
+    const found = findChildren(children, 'isFoo');
+    expect(found).toHaveLength(1);
+    expect(found[0].props.text).toBe('direct-foo');
   });
+});
 
-  describe('styled components', () => {
-    it('should work with styled components from @emotion/styled', () => {
-      const StyledFoo = styled(Foo)`
-        background-color: red;
-        padding: 8px;
-      `;
-
-      const children = [
-        <Foo text="regular-foo" />,
-        <StyledFoo text="styled-foo" />,
-        <StyledFoo text="styled-foo-two" />,
-        <Bar text="regular-bar" />,
-        <Foo text="another-foo" />,
-      ];
-
-      const found = findChildren(children, 'isFoo');
-      expect(found).toHaveLength(4);
-      expect(found.map(c => c.props.text)).toEqual([
-        'regular-foo',
-        'styled-foo',
-        'styled-foo-two',
-        'another-foo',
-      ]);
-
-      // Verify the styled component is actually styled
-      const styledComponent = found[1];
-      const styledType = styledComponent.type as any;
-      const hasEmotionProps = !!(
-        styledType.target || styledType.__emotion_base
-      );
-      expect(hasEmotionProps).toBe(true);
-    });
+describe('styled components', () => {
+  it('should work with styled components from @emotion/styled', () => {
+    const StyledFoo = styled(Foo)`
+      background-color: red;
+      padding: 8px;
+    `;
+
+    const children = [
+      <Foo text="regular-foo" />,
+      <StyledFoo text="styled-foo" />,
+      <StyledFoo text="styled-foo-two" />,
+      <Bar text="regular-bar" />,
+      <Foo text="another-foo" />,
+    ];
+
+    const found = findChildren(children, 'isFoo');
+    expect(found).toHaveLength(4);
+    expect(found.map(c => c.props.text)).toEqual([
+      'regular-foo',
+      'styled-foo',
+      'styled-foo-two',
+      'another-foo',
+    ]);
+
+    // Verify the styled component is actually styled
+    const styledComponent = found[1];
+    const styledType = styledComponent.type as any;
+    const hasEmotionProps = !!(styledType.target || styledType.__emotion_base);
+    expect(hasEmotionProps).toBe(true);
   });
+});
 
-  describe('search depth limitations', () => {
-    it('should NOT find deeply nested components', () => {
-      const children = [
-        <Fragment>
-          <Foo text="single-fragment" />
-        </Fragment>,
+describe('search depth limitations', () => {
+  it('should NOT find deeply nested components', () => {
+    const children = [
+      <Fragment>
+        <Foo text="single-fragment" />
+      </Fragment>,
+      <Fragment>
         <Fragment>
-          <Fragment>
-            <Foo text="double-nested" />
-          </Fragment>
-        </Fragment>,
-        <div>
-          <Foo text="inside-div" />
-        </div>,
-        <Foo text="direct-child" />,
-      ];
-
-      const found = findChildren(children, 'isFoo');
-      expect(found).toHaveLength(1);
-      expect(found[0].props.text).toBe('direct-child');
-    });
+          <Foo text="double-nested" />
+        </Fragment>
+      </Fragment>,
+      <div>
+        <Foo text="inside-div" />
+      </div>,
+      <Foo text="direct-child" />,
+    ];
+
+    const found = findChildren(children, 'isFoo');
+    expect(found).toHaveLength(1);
+    expect(found[0].props.text).toBe('direct-child');
   });
 });
diff --git a/packages/lib/src/childQueries/findChildren/findChildren.ts b/packages/lib/src/childQueries/findChildren/findChildren.ts
index 48632be6f1..b5f12cb0d7 100644
--- a/packages/lib/src/childQueries/findChildren/findChildren.ts
+++ b/packages/lib/src/childQueries/findChildren/findChildren.ts
@@ -15,7 +15,7 @@ import { unwrapRootFragment } from '../unwrapRootFragment';
  * **Styled Component Support:** Checks component.target and component.__emotion_base
  * for styled() wrapped components.
  *
- *  * @example
+ * @example
  * ```ts
  * // ✅ Will find: Direct children
  * findChildren([
@@ -56,7 +56,9 @@ export const findChildren = (
 
   if (!allChildren) return [];
 
-  return allChildren.filter(child =>
-    isChildWithProperty(child, staticProperty),
-  ) as Array<ReactElement>;
+  return allChildren
+    .flat()
+    .filter(child =>
+      isChildWithProperty(child, staticProperty),
+    ) as Array<ReactElement>;
 };
diff --git a/packages/wizard/README.md b/packages/wizard/README.md
new file mode 100644
index 0000000000..5917ed76b8
--- /dev/null
+++ b/packages/wizard/README.md
@@ -0,0 +1,158 @@
+# Wizard
+
+![npm (scoped)](https://img.shields.io/npm/v/@leafygreen-ui/wizard.svg)
+
+#### [View on MongoDB.design](https://www.mongodb.design/component/wizard/live-example/)
+
+## Installation
+
+### PNPM
+
+```shell
+pnpm add @leafygreen-ui/wizard
+```
+
+### Yarn
+
+```shell
+yarn add @leafygreen-ui/wizard
+```
+
+### NPM
+
+```shell
+npm install @leafygreen-ui/wizard
+```
+
+```tsx
+<Wizard>
+  <Wizard.Step>
+    <div>Step 1 contents<div>
+    <Wizard.Footer
+      primaryButtonProps={{
+        children: 'Continue',
+        variant: 'primary'
+      }}
+    />
+  </Wizard.Step>
+
+  <Wizard.Step requiresAcknowledgement>
+    <div>Step 2 contents<div>
+    <Wizard.Footer
+      primaryButtonProps={{
+        children: 'Delete',
+        variant: 'danger'
+      }}
+    />
+  </Wizard.Step>
+</Wizard>
+```
+
+### Wizard
+
+The `Wizard` component establishes a context with an internal state, and will render only the `activeStep`.
+
+You can also control the Wizard externally using the `activeStep` and `onStepChange` callback.
+
+```tsx
+<Wizard
+  activeStep={0}
+  onStepChange={() => {
+    /* do something */
+  }}
+/>
+```
+
+Note: When the `activeStep` is externally controlled, ensure that the provided `activeStep` index is valid relative to the count of steps available. If the zero-indexed `activeStep` value exceeds the count of steps provided (or is negative), nothing will render inside the Wizard. (i.e. passing `activeStep={2}` to a Wizard with only 2 steps, nothing will render)
+
+### Wizard.Step
+
+Defines a discrete step in the wizard. Only the step matching the internal (or provided) `activeStep` index will be displayed.
+
+Both `Wizard` and `Wizard.Step` are only wrapped in a `Fragment` to allow for more versatile styling.
+
+#### `requiresAcknowledgement`
+
+If `requiresAcknowledgement` is true, the step must be acknowledged for the Footer's primary button to be enabled. By default (or when explicitly set to `false`) the primary button will always be enabled.
+
+To set a step to be acknowledged, call `setIsAcknowledged` provided from the `useWizardStepContext` hook.
+e.g.
+
+```tsx
+// App.tsx
+<Wizard.Step requiresAcknowledgement>
+  <MyWizardStepContents />
+  <Wizard.Footer
+    primaryButtonProps={{
+      children: 'Delete', // This button will be disabled until the step has been acknowledged
+    }}
+  />
+</Wizard.Step>;
+
+// MyWizardStepContents.tsx
+const MyWizardStepContents = () => {
+  const { isAcknowledged, setAcknowledged } = useWizardStepContext();
+
+  return (
+    <>
+      <Checkbox
+        label="Acknowledge"
+        checked={isAcknowledged}
+        onChange={e => setAcknowledged(e.target.checked)}
+      />
+    </>
+  );
+};
+```
+
+### Wizard.Footer
+
+The `Wizard.Footer` is a convenience wrapper around the `FormFooter` component. Each step should render its own Footer component
+
+# Test Harnesses
+
+## getTestUtils()
+
+`getTestUtils()` is a util that allows consumers to reliably interact with LG `Wizard` in a product test suite. If the `Wizard` component cannot be found, an error will be thrown.
+
+### Usage
+
+```tsx
+import { getTestUtils } from '@leafygreen-ui/wizard';
+
+const utils = getTestUtils(lgId?: `lg-${string}`); // lgId refers to the custom `data-lgid` attribute passed to `Wizard`. It defaults to 'lg-wizard' if left empty.
+```
+
+### Test Utils
+
+```tsx
+const {
+  getFooter,
+  queryFooter,
+  findFooter,
+  getPrimaryButton,
+  queryPrimaryButton,
+  findPrimaryButton,
+  getBackButton,
+  queryBackButton,
+  findBackButton,
+  getCancelButton,
+  queryCancelButton,
+  findCancelButton,
+} = getTestUtils();
+```
+
+| Util                   | Description                                                   | Returns                       |
+| ---------------------- | ------------------------------------------------------------- | ----------------------------- |
+| `getFooter()`          | Returns the footer element                                    | `HTMLElement`                 |
+| `queryFooter()`        | Returns the footer element or null if not found               | `HTMLElement` \| `null`       |
+| `findFooter()`         | Returns a promise that resolves to the footer element         | `Promise<HTMLElement>`        |
+| `getPrimaryButton()`   | Returns the primary button element                            | `HTMLButtonElement`           |
+| `queryPrimaryButton()` | Returns the primary button element or null if not found       | `HTMLButtonElement` \| `null` |
+| `findPrimaryButton()`  | Returns a promise that resolves to the primary button element | `Promise<HTMLButtonElement>`  |
+| `getBackButton()`      | Returns the back button element                               | `HTMLButtonElement`           |
+| `queryBackButton()`    | Returns the back button element or null if not found          | `HTMLButtonElement` \| `null` |
+| `findBackButton()`     | Returns a promise that resolves to the back button element    | `Promise<HTMLButtonElement>`  |
+| `getCancelButton()`    | Returns the cancel button element                             | `HTMLButtonElement`           |
+| `queryCancelButton()`  | Returns the cancel button element or null if not found        | `HTMLButtonElement` \| `null` |
+| `findCancelButton()`   | Returns a promise that resolves to the cancel button element  | `Promise<HTMLButtonElement>`  |
diff --git a/packages/wizard/package.json b/packages/wizard/package.json
new file mode 100644
index 0000000000..ffa0e34b5f
--- /dev/null
+++ b/packages/wizard/package.json
@@ -0,0 +1,61 @@
+{
+  "name": "@leafygreen-ui/wizard",
+  "version": "0.1.0-local.1",
+  "description": "LeafyGreen UI Kit Wizard",
+  "main": "./dist/umd/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "license": "Apache-2.0",
+  "exports": {
+    ".": {
+      "require": "./dist/umd/index.js",
+      "import": "./dist/esm/index.js",
+      "types": "./dist/types/index.d.ts"
+    },
+    "./testing": {
+      "require": "./dist/umd/testing/index.js",
+      "import": "./dist/esm/testing/index.js",
+      "types": "./dist/types/testing/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "lg-build bundle",
+    "tsc": "lg-build tsc",
+    "docs": "lg-build docs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@leafygreen-ui/button": "workspace:^",
+    "@leafygreen-ui/compound-component": "workspace:^",
+    "@leafygreen-ui/emotion": "workspace:^",
+    "@leafygreen-ui/form-footer": "workspace:^",
+    "@leafygreen-ui/hooks": "workspace:^",
+    "@leafygreen-ui/lib": "workspace:^",
+    "@leafygreen-ui/polymorphic": "workspace:^",
+    "@leafygreen-ui/tokens": "workspace:^",
+    "@lg-tools/test-harnesses": "workspace:^"
+  },
+  "devDependencies": {
+    "@faker-js/faker": "^8.0.0",
+    "@leafygreen-ui/badge": "workspace:^",
+    "@leafygreen-ui/banner": "workspace:^",
+    "@leafygreen-ui/card": "workspace:^",
+    "@leafygreen-ui/checkbox": "workspace:^",
+    "@leafygreen-ui/expandable-card": "workspace:^",
+    "@leafygreen-ui/icon": "workspace:^",
+    "@leafygreen-ui/loading-indicator": "workspace:^",
+    "@leafygreen-ui/segmented-control": "workspace:^",
+    "@leafygreen-ui/skeleton-loader": "workspace:^",
+    "@leafygreen-ui/typography": "workspace:^"
+  },
+  "homepage": "https://github.com/mongodb/leafygreen-ui/tree/main/packages/wizard",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mongodb/leafygreen-ui"
+  },
+  "bugs": {
+    "url": "https://jira.mongodb.org/projects/LG/summary"
+  }
+}
diff --git a/packages/wizard/src/Wizard.stories.tsx b/packages/wizard/src/Wizard.stories.tsx
new file mode 100644
index 0000000000..165a55f7ee
--- /dev/null
+++ b/packages/wizard/src/Wizard.stories.tsx
@@ -0,0 +1,154 @@
+/* eslint-disable no-console */
+import React, { PropsWithChildren } from 'react';
+import { faker } from '@faker-js/faker';
+import { StoryMetaType } from '@lg-tools/storybook-utils';
+import { StoryObj } from '@storybook/react';
+
+import { Banner } from '@leafygreen-ui/banner';
+import { Card } from '@leafygreen-ui/card';
+import { Checkbox } from '@leafygreen-ui/checkbox';
+import { css } from '@leafygreen-ui/emotion';
+import { isDefined } from '@leafygreen-ui/lib';
+import { Body, Description, H3, InlineCode } from '@leafygreen-ui/typography';
+
+import { useWizardStepContext, Wizard } from '.';
+
+faker.seed(0);
+
+const ExampleStepConfig = [
+  {
+    title: 'Apple',
+    description: faker.lorem.paragraph(),
+    content: faker.lorem.paragraph(10),
+    requiresAcknowledgement: true,
+    primaryButtonText: 'Continue',
+  },
+  {
+    title: 'Banana',
+    description: faker.lorem.paragraph(),
+    content: faker.lorem.paragraph(10),
+    requiresAcknowledgement: false,
+    primaryButtonText: 'Continue',
+  },
+  {
+    title: 'Carrot',
+    description: faker.lorem.paragraph(),
+    content: faker.lorem.paragraph(10),
+    requiresAcknowledgement: true,
+    primaryButtonText: 'Finish',
+  },
+];
+
+export default {
+  title: 'Composition/Wizard',
+  component: Wizard,
+  parameters: {
+    default: 'LiveExample',
+  },
+  decorators: [
+    Fn => (
+      <div style={{ height: '100vh', width: '100vw' }}>
+        <Fn />
+      </div>
+    ),
+  ],
+} satisfies StoryMetaType<typeof Wizard>;
+
+const ExampleContentCard = ({ children }: PropsWithChildren<{}>) => {
+  const { isAcknowledged, setAcknowledged, requiresAcknowledgement } =
+    useWizardStepContext();
+
+  return (
+    <Card
+      className={css`
+        margin: 24px;
+        & > * {
+          margin-block: 8px;
+        }
+      `}
+    >
+      {requiresAcknowledgement && (
+        <Checkbox
+          label="Acknowledge"
+          checked={isAcknowledged}
+          onChange={e => setAcknowledged(e.target.checked)}
+        />
+      )}
+      {children}
+    </Card>
+  );
+};
+
+export const LiveExample: StoryObj<typeof Wizard> = {
+  parameters: {
+    controls: {
+      exclude: ['children', 'activeStep', 'onStepChange'],
+    },
+  },
+  render: args => (
+    <Wizard
+      activeStep={args.activeStep}
+      onStepChange={x =>
+        console.log(`[Storybook] activeStep should change to ${x}`)
+      }
+      {...args}
+    >
+      {ExampleStepConfig.map(
+        (
+          {
+            title,
+            description,
+            content,
+            primaryButtonText,
+            requiresAcknowledgement,
+          },
+          i,
+        ) => (
+          <Wizard.Step
+            key={i}
+            requiresAcknowledgement={requiresAcknowledgement}
+          >
+            <H3>
+              Step {i + 1}: {title}
+            </H3>
+            <Description>{description}</Description>
+            <ExampleContentCard>
+              {isDefined(args.activeStep) && (
+                <Banner variant="warning">
+                  <InlineCode>activeStep</InlineCode> is controlled. Use
+                  Storybook controls to update the step
+                </Banner>
+              )}
+              <Body>{content}</Body>
+            </ExampleContentCard>
+            <Wizard.Footer
+              backButtonProps={{
+                onClick: () => console.log('[Storybook] Clicked Back'),
+              }}
+              cancelButtonProps={{
+                children: 'Cancel',
+                onClick: () => console.log('[Storybook] Clicked Cancel'),
+              }}
+              primaryButtonProps={{
+                children: primaryButtonText,
+                onClick: () => console.log('[Storybook] Clicked Primary'),
+              }}
+            />
+          </Wizard.Step>
+        ),
+      )}
+    </Wizard>
+  ),
+};
+
+export const Controlled: StoryObj<typeof Wizard> = {
+  parameters: {
+    controls: {
+      exclude: ['children', 'onStepChange'],
+    },
+  },
+  args: {
+    activeStep: 0,
+  },
+  render: LiveExample.render,
+};
diff --git a/packages/wizard/src/Wizard/Wizard.spec.tsx b/packages/wizard/src/Wizard/Wizard.spec.tsx
new file mode 100644
index 0000000000..07b3f39c17
--- /dev/null
+++ b/packages/wizard/src/Wizard/Wizard.spec.tsx
@@ -0,0 +1,405 @@
+import React from 'react';
+import { render } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+import { getTestUtils } from '../testing';
+import { useWizardStepContext } from '../WizardStep';
+
+import { Wizard } from '.';
+
+describe('packages/wizard', () => {
+  describe('rendering', () => {
+    test('renders first Wizard.Step', () => {
+      const { getByTestId, queryByTestId } = render(
+        <Wizard>
+          <Wizard.Step>
+            <div data-testid="step-1-content">Step 1 content</div>
+          </Wizard.Step>
+          <Wizard.Step>
+            <div data-testid="step-2-content">Step 2 content</div>
+          </Wizard.Step>
+        </Wizard>,
+      );
+      expect(getByTestId('step-1-content')).toBeInTheDocument();
+      expect(queryByTestId('step-2-content')).not.toBeInTheDocument();
+    });
+
+    test('renders Wizard.Footer', () => {
+      const { getByTestId } = render(
+        <Wizard>
+          <Wizard.Step>
+            <div data-testid="step-content">Content</div>
+            <Wizard.Footer
+              data-testid="wizard-footer"
+              primaryButtonProps={{ children: 'Next' }}
+              cancelButtonProps={{ children: 'Cancel' }}
+            />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      expect(getByTestId('wizard-footer')).toBeInTheDocument();
+    });
+
+    test('does not render any other elements', () => {
+      const { queryByTestId } = render(
+        <Wizard>
+          <div data-testid="invalid-element-1">This should not render</div>
+        </Wizard>,
+      );
+
+      // Non-wizard elements should not be rendered
+      expect(queryByTestId('invalid-element-1')).not.toBeInTheDocument();
+    });
+
+    test('renders correct step when activeStep is provided', () => {
+      const { queryByTestId, getByTestId } = render(
+        <Wizard activeStep={1}>
+          <Wizard.Step>
+            <div data-testid="step-1-content">Step 1 content</div>
+          </Wizard.Step>
+          <Wizard.Step>
+            <div data-testid="step-2-content">Step 2 content</div>
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      // Should render the second step when activeStep is 1
+      expect(queryByTestId('step-1-content')).not.toBeInTheDocument();
+      expect(getByTestId('step-2-content')).toBeInTheDocument();
+    });
+
+    test('does not render back button on first step', () => {
+      render(
+        <Wizard activeStep={0}>
+          <Wizard.Step>
+            <div data-testid="step-1-content">Content 1</div>
+            <Wizard.Footer
+              backButtonProps={{ children: 'Back' }}
+              primaryButtonProps={{ children: 'Next' }}
+            />
+          </Wizard.Step>
+          <Wizard.Step>
+            <div data-testid="step-2-content">Content 2</div>
+            <Wizard.Footer
+              backButtonProps={{ children: 'Back' }}
+              primaryButtonProps={{ children: 'Next' }}
+            />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { queryBackButton, getPrimaryButton } = getTestUtils();
+
+      // Back button should not be rendered on first step
+      expect(queryBackButton()).not.toBeInTheDocument();
+      expect(getPrimaryButton()).toBeInTheDocument();
+    });
+
+    test('renders back button on second step', () => {
+      render(
+        <Wizard activeStep={1}>
+          <Wizard.Step>
+            <div data-testid="step-1-content">Content 1</div>
+            <Wizard.Footer
+              backButtonProps={{ children: 'Back' }}
+              primaryButtonProps={{ children: 'Next' }}
+            />
+          </Wizard.Step>
+          <Wizard.Step>
+            <div data-testid="step-2-content">Content 2</div>
+            <Wizard.Footer
+              backButtonProps={{ children: 'Back' }}
+              primaryButtonProps={{ children: 'Next' }}
+            />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { getBackButton, getPrimaryButton } = getTestUtils();
+
+      expect(getBackButton()).toBeInTheDocument();
+      expect(getPrimaryButton()).toBeInTheDocument();
+    });
+  });
+
+  describe('interaction', () => {
+    test('calls `onStepChange` when incrementing step', async () => {
+      const onStepChange = jest.fn();
+
+      render(
+        <Wizard activeStep={0} onStepChange={onStepChange}>
+          <Wizard.Step>
+            <div data-testid="step-1-content">Content 1</div>
+            <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+          </Wizard.Step>
+          <Wizard.Step>
+            <div data-testid="step-2-content">Content 2</div>
+            <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { getPrimaryButton } = getTestUtils();
+      userEvent.click(getPrimaryButton());
+
+      expect(onStepChange).toHaveBeenCalledWith(1);
+    });
+
+    test('calls `onStepChange` when decrementing step', async () => {
+      const onStepChange = jest.fn();
+
+      render(
+        <Wizard activeStep={1} onStepChange={onStepChange}>
+          <Wizard.Step>
+            <div data-testid="step-1-content">Content 1</div>
+            <Wizard.Footer
+              backButtonProps={{ children: 'Back' }}
+              primaryButtonProps={{ children: 'Next' }}
+            />
+          </Wizard.Step>
+          <Wizard.Step>
+            <div data-testid="step-2-content">Content 2</div>
+            <Wizard.Footer
+              backButtonProps={{ children: 'Back' }}
+              primaryButtonProps={{ children: 'Next' }}
+            />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { getBackButton } = getTestUtils();
+      userEvent.click(getBackButton());
+
+      expect(onStepChange).toHaveBeenCalledWith(0);
+    });
+
+    test('calls custom button onClick handlers', async () => {
+      const onStepChange = jest.fn();
+      const onBackClick = jest.fn();
+      const onPrimaryClick = jest.fn();
+      const onCancelClick = jest.fn();
+
+      render(
+        <Wizard activeStep={1} onStepChange={onStepChange}>
+          <Wizard.Step>
+            <div data-testid="step-1-content">Content 1</div>
+            <Wizard.Footer
+              backButtonProps={{ children: 'Back', onClick: onBackClick }}
+              primaryButtonProps={{ children: 'Next', onClick: onPrimaryClick }}
+              cancelButtonProps={{ children: 'Cancel', onClick: onCancelClick }}
+            />
+          </Wizard.Step>
+          <Wizard.Step>
+            <div data-testid="step-2-content">Content 2</div>
+            <Wizard.Footer
+              backButtonProps={{ children: 'Back', onClick: onBackClick }}
+              primaryButtonProps={{ children: 'Next', onClick: onPrimaryClick }}
+              cancelButtonProps={{ children: 'Cancel', onClick: onCancelClick }}
+            />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { getBackButton, getPrimaryButton, getCancelButton } =
+        getTestUtils();
+
+      userEvent.click(getBackButton());
+      expect(onBackClick).toHaveBeenCalled();
+      expect(onStepChange).toHaveBeenCalledWith(0);
+
+      userEvent.click(getPrimaryButton());
+      expect(onPrimaryClick).toHaveBeenCalled();
+      expect(onStepChange).toHaveBeenCalledWith(1);
+
+      userEvent.click(getCancelButton());
+      expect(onCancelClick).toHaveBeenCalled();
+    });
+
+    describe('uncontrolled', () => {
+      test('does not increment step beyond Steps count', async () => {
+        const { getByTestId, queryByTestId } = render(
+          <Wizard>
+            <Wizard.Step>
+              <div data-testid="step-1-content">Content 1</div>
+              <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+            </Wizard.Step>
+            <Wizard.Step>
+              <div data-testid="step-2-content">Content 2</div>
+              <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+            </Wizard.Step>
+          </Wizard>,
+        );
+
+        const { getPrimaryButton } = getTestUtils();
+
+        // Start at step 1
+        expect(getByTestId('step-1-content')).toBeInTheDocument();
+
+        // Click next to go to step 2
+        userEvent.click(getPrimaryButton());
+        expect(getByTestId('step-2-content')).toBeInTheDocument();
+        expect(queryByTestId('step-1-content')).not.toBeInTheDocument();
+
+        // Click next again - should stay at step 2 (last step)
+        userEvent.click(getPrimaryButton());
+        expect(getByTestId('step-2-content')).toBeInTheDocument();
+        expect(queryByTestId('step-1-content')).not.toBeInTheDocument();
+      });
+    });
+
+    describe('controlled', () => {
+      test('does not change steps internally when controlled', async () => {
+        const onStepChange = jest.fn();
+
+        const { getByTestId, queryByTestId } = render(
+          <Wizard activeStep={0} onStepChange={onStepChange}>
+            <Wizard.Step>
+              <div data-testid="step-1-content">Content 1</div>
+              <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+            </Wizard.Step>
+            <Wizard.Step>
+              <div data-testid="step-2-content">Content 2</div>
+              <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+            </Wizard.Step>
+          </Wizard>,
+        );
+
+        const { getPrimaryButton } = getTestUtils();
+
+        // Should start at step 1
+        expect(getByTestId('step-1-content')).toBeInTheDocument();
+
+        // Click next
+        userEvent.click(getPrimaryButton());
+
+        // Should still be at step 1 since it's controlled
+        expect(getByTestId('step-1-content')).toBeInTheDocument();
+        expect(queryByTestId('step-2-content')).not.toBeInTheDocument();
+
+        // But onStepChange should have been called
+        expect(onStepChange).toHaveBeenCalledWith(1);
+      });
+
+      test('warns when activeStep exceeds number of steps', () => {
+        const consoleWarnSpy = jest
+          .spyOn(console, 'warn')
+          .mockImplementation(() => {});
+
+        render(
+          <Wizard activeStep={5}>
+            <Wizard.Step>
+              <div data-testid="step-1-content">Content 1</div>
+            </Wizard.Step>
+            <Wizard.Step>
+              <div data-testid="step-2-content">Content 2</div>
+            </Wizard.Step>
+          </Wizard>,
+        );
+
+        expect(consoleWarnSpy).toHaveBeenCalledWith(
+          'LeafyGreen Wizard received (zero-indexed) `activeStep` prop exceeding the number of Steps provided\n',
+          'Received activeStep: 5, Wizard.Steps count: 2',
+        );
+
+        consoleWarnSpy.mockRestore();
+      });
+
+      test('warns when activeStep is negative', () => {
+        const consoleWarnSpy = jest
+          .spyOn(console, 'warn')
+          .mockImplementation(() => {});
+
+        render(
+          <Wizard activeStep={-1}>
+            <Wizard.Step>
+              <div data-testid="step-1-content">Content 1</div>
+            </Wizard.Step>
+            <Wizard.Step>
+              <div data-testid="step-2-content">Content 2</div>
+            </Wizard.Step>
+          </Wizard>,
+        );
+
+        expect(consoleWarnSpy).toHaveBeenCalledWith(
+          'LeafyGreen Wizard received (zero-indexed) `activeStep` prop exceeding the number of Steps provided\n',
+          'Received activeStep: -1, Wizard.Steps count: 2',
+        );
+
+        consoleWarnSpy.mockRestore();
+      });
+    });
+
+    describe('requiresAcknowledgement', () => {
+      test('disables primary button when requiresAcknowledgement is true and not acknowledged', () => {
+        render(
+          <Wizard>
+            <Wizard.Step requiresAcknowledgement>
+              <div data-testid="step-1-content">Content 1</div>
+              <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+            </Wizard.Step>
+          </Wizard>,
+        );
+
+        const { isPrimaryButtonDisabled } = getTestUtils();
+        expect(isPrimaryButtonDisabled()).toBe(true);
+      });
+
+      test('enables primary button when requiresAcknowledgement is true and acknowledged', async () => {
+        const AcknowledgeButton = () => {
+          const { setAcknowledged } = useWizardStepContext();
+          return (
+            <button onClick={() => setAcknowledged(true)}>Acknowledge</button>
+          );
+        };
+
+        const { getByRole } = render(
+          <Wizard>
+            <Wizard.Step requiresAcknowledgement>
+              <div data-testid="step-1-content">Content 1</div>
+              <AcknowledgeButton />
+              <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+            </Wizard.Step>
+          </Wizard>,
+        );
+
+        const { isPrimaryButtonDisabled } = getTestUtils();
+        expect(isPrimaryButtonDisabled()).toBe(true);
+
+        // Acknowledge the step
+        const acknowledgeButton = getByRole('button', { name: 'Acknowledge' });
+        userEvent.click(acknowledgeButton);
+
+        expect(isPrimaryButtonDisabled()).toBe(false);
+      });
+
+      test('enables primary button when requiresAcknowledgement is false', () => {
+        render(
+          <Wizard>
+            <Wizard.Step requiresAcknowledgement={false}>
+              <div data-testid="step-1-content">Content 1</div>
+              <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+            </Wizard.Step>
+          </Wizard>,
+        );
+
+        const { isPrimaryButtonDisabled } = getTestUtils();
+        expect(isPrimaryButtonDisabled()).toBe(false);
+      });
+
+      test('enables primary button when requiresAcknowledgement is not set (default)', () => {
+        render(
+          <Wizard>
+            <Wizard.Step>
+              <div data-testid="step-1-content">Content 1</div>
+              <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+            </Wizard.Step>
+          </Wizard>,
+        );
+
+        const { isPrimaryButtonDisabled } = getTestUtils();
+        expect(isPrimaryButtonDisabled()).toBe(false);
+      });
+    });
+  });
+});
diff --git a/packages/wizard/src/Wizard/Wizard.styles.ts b/packages/wizard/src/Wizard/Wizard.styles.ts
new file mode 100644
index 0000000000..a20d2f2a15
--- /dev/null
+++ b/packages/wizard/src/Wizard/Wizard.styles.ts
@@ -0,0 +1,10 @@
+import { css } from '@leafygreen-ui/emotion';
+import { spacing } from '@leafygreen-ui/tokens';
+
+export const wizardContainerStyles = css`
+  width: 100%;
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  gap: ${spacing[600]}px;
+`;
diff --git a/packages/wizard/src/Wizard/Wizard.tsx b/packages/wizard/src/Wizard/Wizard.tsx
new file mode 100644
index 0000000000..c1d2a7a4ed
--- /dev/null
+++ b/packages/wizard/src/Wizard/Wizard.tsx
@@ -0,0 +1,97 @@
+import React, { useCallback } from 'react';
+
+import {
+  CompoundComponent,
+  findChildren,
+} from '@leafygreen-ui/compound-component';
+import { useControlled } from '@leafygreen-ui/hooks';
+
+import { WizardSubComponentProperties } from '../constants';
+import { getLgIds } from '../utils/getLgIds';
+import { WizardProvider } from '../WizardContext/WizardContext';
+import { WizardFooter } from '../WizardFooter';
+import { WizardStep } from '../WizardStep';
+
+import { WizardProps } from './Wizard.types';
+
+export const Wizard = CompoundComponent(
+  ({
+    activeStep: activeStepProp,
+    onStepChange,
+    children,
+    'data-lgid': dataLgId,
+  }: WizardProps) => {
+    const lgIds = getLgIds(dataLgId);
+    const stepChildren = findChildren(
+      children,
+      WizardSubComponentProperties.Step,
+    );
+
+    // Controlled/Uncontrolled activeStep value
+    const { value: activeStep, updateValue: setActiveStep } =
+      useControlled<number>(activeStepProp, onStepChange, 0);
+
+    if (
+      activeStepProp &&
+      (activeStepProp < 0 || activeStepProp >= stepChildren.length)
+    ) {
+      // Not consoleOnce, since we want to warn again if the step changes
+      console.warn(
+        'LeafyGreen Wizard received (zero-indexed) `activeStep` prop exceeding the number of Steps provided\n',
+        `Received activeStep: ${activeStepProp}, Wizard.Steps count: ${stepChildren.length}`,
+      );
+    }
+
+    const updateStep = useCallback(
+      (step: number) => {
+        // Clamp the step value between 0 and stepChildren.length - 1
+        const clampedStep = Math.max(
+          0,
+          Math.min(step, stepChildren.length - 1),
+        );
+        setActiveStep(clampedStep);
+      },
+      [setActiveStep, stepChildren.length],
+    );
+
+    /**
+     * NB: We're intentionally do _not_ wrap the `Wizard` (or `WizardStep`) component in a container element.
+     * This is done to ensure the Wizard is flexible, and can be rendered in any containing layout.
+     */
+    return (
+      <WizardProvider
+        activeStep={activeStep}
+        updateStep={updateStep}
+        totalSteps={stepChildren.length}
+        lgIds={lgIds}
+      >
+        {stepChildren.map((child, i) => (i === activeStep ? child : null))}
+      </WizardProvider>
+    );
+  },
+  {
+    displayName: 'Wizard',
+    /**
+     * A single step in the wizard. A Wizard will only render Steps as children
+     */
+    Step: WizardStep,
+
+    /**
+     * The footer of a Step component.
+     * Render this inside of each Step with the relevant button props for that Step.
+     *
+     * Back and Primary buttons trigger onStepChange.
+     * Automatically renders the "Back" button for all Steps except the first
+     */
+    Footer: WizardFooter,
+  },
+);
+
+/**
+ * 🤚 Wizard.
+ * 🤚 Wizard.
+ * 🤚 Wizard.
+ * ...
+ * 🤚 Wizard. 🤚 Wizard. 🤚 Wizard.
+ * https://youtu.be/5jGWMtEhS1c
+ */
diff --git a/packages/wizard/src/Wizard/Wizard.types.ts b/packages/wizard/src/Wizard/Wizard.types.ts
new file mode 100644
index 0000000000..fb605deb81
--- /dev/null
+++ b/packages/wizard/src/Wizard/Wizard.types.ts
@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+
+import { LgIdProps } from '@leafygreen-ui/lib';
+
+export interface WizardProps extends LgIdProps {
+  /**
+   * The current active step index (0-based).
+   *
+   * If provided, the component operates in controlled mode, and any interaction will not update internal state.
+   * Use `onStepChange` to update your external state
+   *
+   * Note: when controlling this externally, ensure that the provided `activeStep` index is valid relative to the count of steps available.
+   * If the zero-indexed `activeStep` value exceeds the count of steps provided (or is negative), nothing will render inside the Wizard.
+   */
+  activeStep?: number;
+
+  /**
+   * Callback fired when the active step changes.
+   */
+  onStepChange?: (step: number) => void;
+
+  /**
+   * The wizard steps and footer as children
+   */
+  children: ReactNode;
+}
diff --git a/packages/wizard/src/Wizard/index.ts b/packages/wizard/src/Wizard/index.ts
new file mode 100644
index 0000000000..639f0423de
--- /dev/null
+++ b/packages/wizard/src/Wizard/index.ts
@@ -0,0 +1,2 @@
+export { Wizard } from './Wizard';
+export { type WizardProps } from './Wizard.types';
diff --git a/packages/wizard/src/WizardContext/WizardContext.tsx b/packages/wizard/src/WizardContext/WizardContext.tsx
new file mode 100644
index 0000000000..a8d40c933d
--- /dev/null
+++ b/packages/wizard/src/WizardContext/WizardContext.tsx
@@ -0,0 +1,70 @@
+import React, { createContext, PropsWithChildren, useContext } from 'react';
+
+import { getLgIds } from '../utils/getLgIds';
+import { GetLgIdsReturnType } from '../utils/getLgIds';
+
+export interface WizardContextData {
+  /**
+   * Defines whether the consuming component is within a Wizard context.
+   * This is used to log warnings in sub-components that must be rendered as a Wizard child.
+   */
+  isWizardContext: boolean;
+
+  /**
+   * Defines the currently active Wizard.Step.
+   * Note: when controlling this externally, ensure that the provided `activeStep` index is valid relative to the count of steps available.
+   * If the zero-indexed `activeStep` value exceeds the count of steps provided (or is negative), nothing will render inside the Wizard.
+   */
+  activeStep: number;
+
+  /**
+   * Updates the Wizard `activeStep` to the provided step number.
+   * Note: The Wizard implementation internally handles clamping the step number
+   * to the available number of steps
+   * @param step
+   * @returns
+   */
+  updateStep: (step: number) => void;
+
+  /**
+   * @internal
+   * Internally sets the number of steps in the Wizard
+   */
+  totalSteps: number;
+  lgIds: GetLgIdsReturnType;
+}
+
+export const WizardContext = createContext<WizardContextData>({
+  isWizardContext: false,
+  activeStep: 0,
+  totalSteps: 0,
+  updateStep: () => {},
+  lgIds: getLgIds(),
+});
+
+interface WizardProviderProps
+  extends PropsWithChildren<Omit<WizardContextData, 'isWizardContext'>> {}
+
+export const WizardProvider = ({
+  children,
+  activeStep,
+  updateStep,
+  totalSteps,
+  lgIds = getLgIds(),
+}: WizardProviderProps) => {
+  return (
+    <WizardContext.Provider
+      value={{
+        isWizardContext: true,
+        activeStep,
+        updateStep,
+        totalSteps,
+        lgIds,
+      }}
+    >
+      {children}
+    </WizardContext.Provider>
+  );
+};
+
+export const useWizardContext = () => useContext(WizardContext);
diff --git a/packages/wizard/src/WizardContext/index.ts b/packages/wizard/src/WizardContext/index.ts
new file mode 100644
index 0000000000..4e4bfdda83
--- /dev/null
+++ b/packages/wizard/src/WizardContext/index.ts
@@ -0,0 +1,6 @@
+export {
+  useWizardContext,
+  WizardContext,
+  type WizardContextData,
+  WizardProvider,
+} from './WizardContext';
diff --git a/packages/wizard/src/WizardFooter/WizardFooter.spec.tsx b/packages/wizard/src/WizardFooter/WizardFooter.spec.tsx
new file mode 100644
index 0000000000..9f8f10d366
--- /dev/null
+++ b/packages/wizard/src/WizardFooter/WizardFooter.spec.tsx
@@ -0,0 +1,259 @@
+import React from 'react';
+import { render } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+import { getTestUtils } from '../testing';
+import { Wizard } from '../Wizard';
+import { useWizardStepContext } from '../WizardStep';
+
+import { WizardFooter } from '.';
+
+describe('packages/wizard-footer', () => {
+  test('does not render outside WizardContext', () => {
+    const { container } = render(
+      <WizardFooter
+        data-testid="footer"
+        primaryButtonProps={{ children: 'Next' }}
+      >
+        Content
+      </WizardFooter>,
+    );
+
+    expect(container.firstChild).toBeNull();
+  });
+
+  test('renders in WizardContext', () => {
+    render(
+      <Wizard>
+        <Wizard.Step>
+          <WizardFooter
+            data-testid="footer"
+            primaryButtonProps={{ children: 'Next' }}
+          >
+            Content
+          </WizardFooter>
+        </Wizard.Step>
+      </Wizard>,
+    );
+
+    const { getFooter } = getTestUtils();
+    expect(getFooter()).toBeInTheDocument();
+  });
+
+  describe('primary button behavior', () => {
+    test('primary button is enabled by default', () => {
+      render(
+        <Wizard>
+          <Wizard.Step>
+            <Wizard.Footer primaryButtonProps={{ children: 'Continue' }} />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { isPrimaryButtonDisabled } = getTestUtils();
+      expect(isPrimaryButtonDisabled()).toBe(false);
+    });
+
+    test('primary button advances to next step when clicked', async () => {
+      const onStepChange = jest.fn();
+
+      const { getByTestId } = render(
+        <Wizard onStepChange={onStepChange}>
+          <Wizard.Step>
+            <div data-testid="step-1">Step 1</div>
+            <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+          </Wizard.Step>
+          <Wizard.Step>
+            <div data-testid="step-2">Step 2</div>
+            <Wizard.Footer primaryButtonProps={{ children: 'Finish' }} />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      expect(getByTestId('step-1')).toBeInTheDocument();
+
+      const { getPrimaryButton } = getTestUtils();
+      userEvent.click(getPrimaryButton());
+
+      expect(onStepChange).toHaveBeenCalledWith(1);
+      expect(getByTestId('step-2')).toBeInTheDocument();
+    });
+
+    describe('requiresAcknowledgement', () => {
+      test('primary button is disabled when step requires acknowledgement and is not acknowledged', () => {
+        render(
+          <Wizard>
+            <Wizard.Step requiresAcknowledgement>
+              <div>Step content</div>
+              <Wizard.Footer primaryButtonProps={{ children: 'Continue' }} />
+            </Wizard.Step>
+          </Wizard>,
+        );
+
+        const { isPrimaryButtonDisabled } = getTestUtils();
+        expect(isPrimaryButtonDisabled()).toBe(true);
+      });
+
+      test('primary button is enabled when step requires acknowledgement and is acknowledged', async () => {
+        const TestComponent = () => {
+          const { setAcknowledged } = useWizardStepContext();
+          return (
+            <>
+              <div>Step content</div>
+              <button onClick={() => setAcknowledged(true)}>Acknowledge</button>
+              <Wizard.Footer primaryButtonProps={{ children: 'Continue' }} />
+            </>
+          );
+        };
+
+        const { getByRole } = render(
+          <Wizard>
+            <Wizard.Step requiresAcknowledgement>
+              <TestComponent />
+            </Wizard.Step>
+          </Wizard>,
+        );
+
+        const { isPrimaryButtonDisabled } = getTestUtils();
+        expect(isPrimaryButtonDisabled()).toBe(true);
+
+        await userEvent.click(getByRole('button', { name: 'Acknowledge' }));
+
+        expect(isPrimaryButtonDisabled()).toBe(false);
+      });
+
+      test('primary button is enabled when step does not require acknowledgement', () => {
+        render(
+          <Wizard>
+            <Wizard.Step>
+              <div>Step content</div>
+              <Wizard.Footer primaryButtonProps={{ children: 'Continue' }} />
+            </Wizard.Step>
+          </Wizard>,
+        );
+
+        const { isPrimaryButtonDisabled } = getTestUtils();
+        expect(isPrimaryButtonDisabled()).toBe(false);
+      });
+
+      test('primary button can advance step after acknowledgement', async () => {
+        const TestComponent = () => {
+          const { setAcknowledged } = useWizardStepContext();
+          return (
+            <>
+              <div>Step content</div>
+              <button onClick={() => setAcknowledged(true)}>Acknowledge</button>
+              <Wizard.Footer primaryButtonProps={{ children: 'Continue' }} />
+            </>
+          );
+        };
+
+        const { getByRole, getByTestId } = render(
+          <Wizard>
+            <Wizard.Step requiresAcknowledgement>
+              <div data-testid="step-1">Step 1</div>
+              <TestComponent />
+            </Wizard.Step>
+            <Wizard.Step>
+              <div data-testid="step-2">Step 2</div>
+            </Wizard.Step>
+          </Wizard>,
+        );
+
+        const { isPrimaryButtonDisabled, getPrimaryButton } = getTestUtils();
+
+        expect(getByTestId('step-1')).toBeInTheDocument();
+        expect(isPrimaryButtonDisabled()).toBe(true);
+
+        // Acknowledge the step
+        userEvent.click(getByRole('button', { name: 'Acknowledge' }));
+        expect(isPrimaryButtonDisabled()).toBe(false);
+
+        // Advance to next step
+        userEvent.click(getPrimaryButton());
+        expect(getByTestId('step-2')).toBeInTheDocument();
+      });
+    });
+  });
+
+  describe('back button', () => {
+    test('back button is not rendered on first step', () => {
+      render(
+        <Wizard>
+          <Wizard.Step>
+            <Wizard.Footer
+              primaryButtonProps={{ children: 'Next' }}
+              backButtonProps={{ children: 'Back' }}
+            />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { queryBackButton } = getTestUtils();
+      expect(queryBackButton()).not.toBeInTheDocument();
+    });
+
+    test('back button is rendered on subsequent steps', async () => {
+      render(
+        <Wizard>
+          <Wizard.Step>
+            <div data-testid="step-1">Step 1</div>
+            <Wizard.Footer
+              primaryButtonProps={{ children: 'Next' }}
+              backButtonProps={{ children: 'Back' }}
+            />
+          </Wizard.Step>
+          <Wizard.Step>
+            <div data-testid="step-2">Step 2</div>
+            <Wizard.Footer
+              primaryButtonProps={{ children: 'Finish' }}
+              backButtonProps={{ children: 'Back' }}
+            />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { getPrimaryButton, getBackButton } = getTestUtils();
+
+      // Move to step 2
+      userEvent.click(getPrimaryButton());
+
+      // Back button should now be visible
+      expect(getBackButton()).toBeInTheDocument();
+    });
+
+    test('back button navigates to previous step', async () => {
+      const onStepChange = jest.fn();
+
+      const { getByTestId } = render(
+        <Wizard onStepChange={onStepChange}>
+          <Wizard.Step>
+            <div data-testid="step-1">Step 1</div>
+            <Wizard.Footer
+              primaryButtonProps={{ children: 'Next' }}
+              backButtonProps={{ children: 'Back' }}
+            />
+          </Wizard.Step>
+          <Wizard.Step>
+            <div data-testid="step-2">Step 2</div>
+            <Wizard.Footer
+              primaryButtonProps={{ children: 'Finish' }}
+              backButtonProps={{ children: 'Back' }}
+            />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { getPrimaryButton, getBackButton } = getTestUtils();
+
+      // Move to step 2
+      userEvent.click(getPrimaryButton());
+      expect(getByTestId('step-2')).toBeInTheDocument();
+
+      // Go back to step 1
+      userEvent.click(getBackButton());
+      expect(onStepChange).toHaveBeenCalledWith(0);
+      expect(getByTestId('step-1')).toBeInTheDocument();
+    });
+  });
+});
diff --git a/packages/wizard/src/WizardFooter/WizardFooter.stories.tsx b/packages/wizard/src/WizardFooter/WizardFooter.stories.tsx
new file mode 100644
index 0000000000..a332249682
--- /dev/null
+++ b/packages/wizard/src/WizardFooter/WizardFooter.stories.tsx
@@ -0,0 +1,84 @@
+import React from 'react';
+import { StoryMetaType } from '@lg-tools/storybook-utils';
+import { StoryObj } from '@storybook/react';
+
+import { Variant } from '@leafygreen-ui/button';
+import { glyphs, Icon } from '@leafygreen-ui/icon';
+
+import { WizardProvider } from '../WizardContext';
+
+import { WizardFooter, type WizardFooterProps } from '.';
+
+type PrimaryButtonVariant =
+  Required<WizardFooterProps>['primaryButtonProps']['variant'];
+interface StoryArgs {
+  backButtonText: string;
+  backButtonIcon: keyof typeof glyphs;
+  cancelButtonText: string;
+  primaryButtonText: string;
+  primaryButtonIcon: keyof typeof glyphs;
+  primaryButtonVariant: PrimaryButtonVariant;
+}
+
+const meta: StoryMetaType<typeof WizardFooter, StoryArgs> = {
+  title: 'Composition/Wizard/WizardFooter',
+  component: WizardFooter,
+  parameters: {
+    default: 'LiveExample',
+    controls: {
+      exclude: ['backButtonProps', 'cancelButtonProps', 'primaryButtonProps'],
+    },
+  },
+  args: {},
+  argTypes: {
+    backButtonText: { control: 'text' },
+    backButtonIcon: { control: 'select', options: Object.keys(glyphs) },
+    cancelButtonText: { control: 'text' },
+    primaryButtonText: { control: 'text' },
+    primaryButtonIcon: { control: 'select', options: Object.keys(glyphs) },
+    primaryButtonVariant: {
+      control: 'select',
+      options: [Variant.Primary, Variant.Danger],
+    },
+  },
+};
+
+export default meta;
+
+export const LiveExample: StoryObj<StoryArgs> = {
+  args: {
+    backButtonText: 'Back',
+    backButtonIcon: 'ArrowLeft',
+    cancelButtonText: 'Cancel',
+    primaryButtonText: 'Continue',
+    primaryButtonIcon: 'Ellipsis',
+    primaryButtonVariant: Variant.Primary,
+  },
+  decorators: [
+    Story => (
+      <WizardProvider activeStep={1} updateStep={() => {}}>
+        <Story />
+      </WizardProvider>
+    ),
+  ],
+  render: args => (
+    <WizardFooter
+      backButtonProps={{
+        leftGlyph: args.backButtonIcon ? (
+          <Icon glyph={args.backButtonIcon} />
+        ) : undefined,
+        children: args.backButtonText,
+      }}
+      cancelButtonProps={{
+        children: args.cancelButtonText,
+      }}
+      primaryButtonProps={{
+        leftGlyph: args.primaryButtonIcon ? (
+          <Icon glyph={args.primaryButtonIcon} />
+        ) : undefined,
+        children: args.primaryButtonText,
+        variant: args.primaryButtonVariant,
+      }}
+    />
+  ),
+};
diff --git a/packages/wizard/src/WizardFooter/WizardFooter.styles.ts b/packages/wizard/src/WizardFooter/WizardFooter.styles.ts
new file mode 100644
index 0000000000..90e2e8cc60
--- /dev/null
+++ b/packages/wizard/src/WizardFooter/WizardFooter.styles.ts
@@ -0,0 +1,5 @@
+import { css } from '@leafygreen-ui/emotion';
+
+export const baseStyles = css`
+  width: 100%;
+`;
diff --git a/packages/wizard/src/WizardFooter/WizardFooter.tsx b/packages/wizard/src/WizardFooter/WizardFooter.tsx
new file mode 100644
index 0000000000..a1a52bd7a4
--- /dev/null
+++ b/packages/wizard/src/WizardFooter/WizardFooter.tsx
@@ -0,0 +1,79 @@
+import React, { MouseEventHandler } from 'react';
+
+import { CompoundSubComponent } from '@leafygreen-ui/compound-component';
+import { FormFooter } from '@leafygreen-ui/form-footer';
+import { consoleOnce } from '@leafygreen-ui/lib';
+
+import { WizardSubComponentProperties } from '../constants';
+import { useWizardContext } from '../WizardContext';
+import { useWizardStepContext } from '../WizardStep';
+
+import { WizardFooterProps } from './WizardFooter.types';
+
+export const WizardFooter = CompoundSubComponent(
+  ({
+    backButtonProps,
+    cancelButtonProps,
+    primaryButtonProps,
+    className,
+    ...rest
+  }: WizardFooterProps) => {
+    const { isWizardContext, activeStep, updateStep, lgIds } =
+      useWizardContext();
+    const { isAcknowledged, requiresAcknowledgement } = useWizardStepContext();
+    const isPrimaryButtonDisabled =
+      (requiresAcknowledgement && !isAcknowledged) ||
+      primaryButtonProps.disabled ||
+      false;
+
+    const handleBackButtonClick: MouseEventHandler<HTMLButtonElement> = e => {
+      updateStep(activeStep - 1);
+      backButtonProps?.onClick?.(e);
+    };
+
+    const handlePrimaryButtonClick: MouseEventHandler<
+      HTMLButtonElement
+    > = e => {
+      updateStep(activeStep + 1);
+      primaryButtonProps.onClick?.(e);
+    };
+
+    if (!isWizardContext) {
+      consoleOnce.error(
+        'Wizard.Footer component must be used within a Wizard context.',
+      );
+      return null;
+    }
+
+    return (
+      <FormFooter
+        {...rest}
+        className={className}
+        data-lgid={lgIds.footer}
+        backButtonProps={
+          activeStep > 0
+            ? {
+                'data-lgid': lgIds.footerBackButton,
+                ...backButtonProps,
+                onClick: handleBackButtonClick,
+              }
+            : undefined
+        }
+        cancelButtonProps={{
+          'data-lgid': lgIds.footerCancelButton,
+          ...cancelButtonProps,
+        }}
+        primaryButtonProps={{
+          'data-lgid': lgIds.footerPrimaryButton,
+          ...primaryButtonProps,
+          disabled: isPrimaryButtonDisabled,
+          onClick: handlePrimaryButtonClick,
+        }}
+      />
+    );
+  },
+  {
+    displayName: 'WizardFooter',
+    key: WizardSubComponentProperties.Footer,
+  },
+);
diff --git a/packages/wizard/src/WizardFooter/WizardFooter.types.ts b/packages/wizard/src/WizardFooter/WizardFooter.types.ts
new file mode 100644
index 0000000000..ec7756342c
--- /dev/null
+++ b/packages/wizard/src/WizardFooter/WizardFooter.types.ts
@@ -0,0 +1,12 @@
+import type {
+  BackStandardButtonProps,
+  CancelStandardButtonProps,
+  FormFooterProps,
+  PrimaryStandardButtonProps,
+} from '@leafygreen-ui/form-footer';
+
+export interface WizardFooterProps extends FormFooterProps {
+  backButtonProps?: BackStandardButtonProps;
+  cancelButtonProps?: CancelStandardButtonProps;
+  primaryButtonProps: PrimaryStandardButtonProps;
+}
diff --git a/packages/wizard/src/WizardFooter/index.ts b/packages/wizard/src/WizardFooter/index.ts
new file mode 100644
index 0000000000..10bb26030a
--- /dev/null
+++ b/packages/wizard/src/WizardFooter/index.ts
@@ -0,0 +1,2 @@
+export { WizardFooter } from './WizardFooter';
+export { type WizardFooterProps } from './WizardFooter.types';
diff --git a/packages/wizard/src/WizardStep/TextNode.tsx b/packages/wizard/src/WizardStep/TextNode.tsx
new file mode 100644
index 0000000000..e75679d7ed
--- /dev/null
+++ b/packages/wizard/src/WizardStep/TextNode.tsx
@@ -0,0 +1,32 @@
+import React, { PropsWithChildren } from 'react';
+
+import { Polymorph, PolymorphicAs } from '@leafygreen-ui/polymorphic';
+
+/**
+ * Wraps a string in the provided `as` component,
+ * or renders the provided `ReactNode`.
+ *
+ * Useful when rendering `children` props that can be any react node
+ *
+ * @example
+ * ```
+ * <TextNode as={h1}>Hello!</TextNode> // <h1>Hello!</h1>
+ * ```
+ *
+ * @example
+ * ```
+ * <TextNode><h2>Hello!</h2></TextNode> // <h2>Hello!</h2>
+ * ```
+ *
+ */
+// TODO: Move to `Typography`
+export const TextNode = ({
+  children,
+  as,
+}: PropsWithChildren<{ as?: PolymorphicAs }>) => {
+  return typeof children === 'string' || typeof children === 'number' ? (
+    <Polymorph as={as}>{children}</Polymorph>
+  ) : (
+    <>{children}</>
+  );
+};
diff --git a/packages/wizard/src/WizardStep/WizardStep.spec.tsx b/packages/wizard/src/WizardStep/WizardStep.spec.tsx
new file mode 100644
index 0000000000..c54404c3a7
--- /dev/null
+++ b/packages/wizard/src/WizardStep/WizardStep.spec.tsx
@@ -0,0 +1,163 @@
+import React from 'react';
+import { render, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+import { getTestUtils } from '../testing';
+import { Wizard } from '../Wizard/Wizard';
+import { useWizardContext } from '../WizardContext';
+import { WizardFooter } from '../WizardFooter';
+
+import { useWizardStepContext, WizardStep } from '.';
+
+describe('packages/wizard-step', () => {
+  test('does not render outside WizardContext', () => {
+    const { container } = render(
+      <WizardStep data-testid="step-1">Content</WizardStep>,
+    );
+
+    expect(container.firstChild).toBeNull();
+  });
+
+  test('renders in WizardContext', () => {
+    const { getByTestId } = render(
+      <Wizard>
+        <Wizard.Step>
+          <div data-testid="step-1">Content</div>
+        </Wizard.Step>
+      </Wizard>,
+    );
+
+    expect(getByTestId('step-1')).toBeInTheDocument();
+  });
+
+  describe('requiresAcknowledgement', () => {
+    test('by default, does not require acknowledgement', () => {
+      const TestComponent = () => {
+        const { requiresAcknowledgement } = useWizardStepContext();
+        return (
+          <div data-testid="requires-ack">
+            {String(requiresAcknowledgement)}
+          </div>
+        );
+      };
+
+      const { getByTestId } = render(
+        <Wizard>
+          <Wizard.Step>
+            <TestComponent />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      expect(getByTestId('requires-ack')).toHaveTextContent('false');
+    });
+
+    test('when true, requires acknowledgement', () => {
+      const TestComponent = () => {
+        const { requiresAcknowledgement } = useWizardStepContext();
+        return (
+          <div data-testid="requires-ack">
+            {String(requiresAcknowledgement)}
+          </div>
+        );
+      };
+
+      const { getByTestId } = render(
+        <Wizard>
+          <Wizard.Step requiresAcknowledgement>
+            <TestComponent />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      expect(getByTestId('requires-ack')).toHaveTextContent('true');
+    });
+
+    test('isAcknowledged is false by default', () => {
+      const TestComponent = () => {
+        const { isAcknowledged } = useWizardStepContext();
+        return <div data-testid="is-ack">{String(isAcknowledged)}</div>;
+      };
+
+      const { getByTestId } = render(
+        <Wizard>
+          <Wizard.Step requiresAcknowledgement>
+            <TestComponent />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      expect(getByTestId('is-ack')).toHaveTextContent('false');
+    });
+
+    test('setAcknowledged updates isAcknowledged state', async () => {
+      const TestComponent = () => {
+        const { isAcknowledged, setAcknowledged } = useWizardStepContext();
+        return (
+          <>
+            <div data-testid="is-ack">{String(isAcknowledged)}</div>
+            <button onClick={() => setAcknowledged(true)}>Acknowledge</button>
+          </>
+        );
+      };
+
+      const { getByTestId, getByRole } = render(
+        <Wizard>
+          <Wizard.Step requiresAcknowledgement>
+            <TestComponent />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      expect(getByTestId('is-ack')).toHaveTextContent('false');
+
+      await userEvent.click(getByRole('button', { name: 'Acknowledge' }));
+
+      expect(getByTestId('is-ack')).toHaveTextContent('true');
+    });
+
+    test('acknowledgement state resets between steps', async () => {
+      const TestComponent = () => {
+        const { activeStep } = useWizardContext();
+        const { isAcknowledged, setAcknowledged } = useWizardStepContext();
+        return (
+          <div data-testid={`step-${activeStep}`}>
+            <div data-testid="is-ack">{String(isAcknowledged)}</div>
+            <button onClick={() => setAcknowledged(true)}>Acknowledge</button>
+          </div>
+        );
+      };
+
+      const { getByTestId, getByRole } = render(
+        <Wizard>
+          <Wizard.Step requiresAcknowledgement>
+            <TestComponent />
+            <WizardFooter primaryButtonProps={{ children: 'Continue' }} />
+          </Wizard.Step>
+          <Wizard.Step requiresAcknowledgement>
+            <TestComponent />
+            <WizardFooter primaryButtonProps={{ children: 'Finish' }} />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      // Step 1: acknowledge and move forward
+      expect(getByTestId('step-0')).toBeInTheDocument();
+      expect(getByTestId('is-ack')).toHaveTextContent('false');
+      userEvent.click(getByRole('button', { name: 'Acknowledge' }));
+      expect(getByTestId('is-ack')).toHaveTextContent('true');
+
+      const { getPrimaryButton } = getTestUtils();
+      userEvent.click(getPrimaryButton());
+
+      await waitFor(() => {
+        expect(getByTestId('step-1')).toBeInTheDocument();
+      });
+
+      // Step 2: Acknowledgement is reset
+      expect(getByTestId('is-ack')).toHaveTextContent('false');
+      userEvent.click(getByRole('button', { name: 'Acknowledge' }));
+      expect(getByTestId('is-ack')).toHaveTextContent('true');
+    });
+  });
+});
diff --git a/packages/wizard/src/WizardStep/WizardStep.stories.tsx b/packages/wizard/src/WizardStep/WizardStep.stories.tsx
new file mode 100644
index 0000000000..5b959d24f8
--- /dev/null
+++ b/packages/wizard/src/WizardStep/WizardStep.stories.tsx
@@ -0,0 +1,66 @@
+import React from 'react';
+import { StoryMetaType } from '@lg-tools/storybook-utils';
+import { StoryObj } from '@storybook/react';
+
+import { Body, Description, H3 } from '@leafygreen-ui/typography';
+
+import { getLgIds } from '../utils/getLgIds';
+import { WizardProvider } from '../WizardContext';
+
+import { WizardStep, WizardStepProps } from '.';
+
+const meta: StoryMetaType<typeof WizardStep> = {
+  title: 'Composition/Wizard/WizardStep',
+  component: WizardStep,
+  parameters: {
+    default: 'LiveExample',
+  },
+  decorators: [
+    Story => (
+      <WizardProvider
+        activeStep={0}
+        updateStep={() => {}}
+        totalSteps={1}
+        lgIds={getLgIds()}
+      >
+        <Story />
+      </WizardProvider>
+    ),
+  ],
+};
+
+export default meta;
+
+interface WizardStepStoryProps extends WizardStepProps {
+  title: string;
+  description: string;
+}
+
+export const LiveExample: StoryObj<WizardStepStoryProps> = {
+  args: {
+    title: 'Step 1: Basic Information',
+    description: 'Please provide your basic information to get started.',
+    children: (
+      <div>
+        <Body>This is the content of the step.</Body>
+        <Body>
+          You can include forms, instructions, or any other content here.
+        </Body>
+      </div>
+    ),
+  },
+  argTypes: {
+    title: { control: 'text' },
+    description: { control: 'text' },
+    children: { control: 'text' },
+  },
+  render: args => (
+    <WizardStep>
+      <div>
+        <H3>{args.title}</H3>
+        <Description>{args.description}</Description>
+        <Body>{args.children}</Body>
+      </div>
+    </WizardStep>
+  ),
+};
diff --git a/packages/wizard/src/WizardStep/WizardStep.styles.ts b/packages/wizard/src/WizardStep/WizardStep.styles.ts
new file mode 100644
index 0000000000..b38acdf587
--- /dev/null
+++ b/packages/wizard/src/WizardStep/WizardStep.styles.ts
@@ -0,0 +1,6 @@
+import { css } from '@leafygreen-ui/emotion';
+import { spacing } from '@leafygreen-ui/tokens';
+
+export const stepStyles = css`
+  padding: 0 ${spacing[1800]}px;
+`;
diff --git a/packages/wizard/src/WizardStep/WizardStep.tsx b/packages/wizard/src/WizardStep/WizardStep.tsx
new file mode 100644
index 0000000000..26cd587ea2
--- /dev/null
+++ b/packages/wizard/src/WizardStep/WizardStep.tsx
@@ -0,0 +1,56 @@
+import React from 'react';
+
+import {
+  CompoundSubComponent,
+  filterChildren,
+  findChild,
+} from '@leafygreen-ui/compound-component';
+import { useIdAllocator } from '@leafygreen-ui/hooks';
+import { consoleOnce } from '@leafygreen-ui/lib';
+
+import { WizardSubComponentProperties } from '../constants';
+import { useWizardContext } from '../WizardContext';
+
+import { WizardStepProps } from './WizardStep.types';
+import { WizardStepProvider } from './WizardStepContext';
+
+export const WizardStep = CompoundSubComponent(
+  ({ children, requiresAcknowledgement = false }: WizardStepProps) => {
+    const stepId = useIdAllocator({ prefix: 'wizard-step' });
+    const { isWizardContext } = useWizardContext();
+
+    if (!isWizardContext) {
+      consoleOnce.error(
+        'Wizard.Step component must be used within a Wizard context.',
+      );
+      return null;
+    }
+
+    const footerChild = findChild(
+      children,
+      WizardSubComponentProperties.Footer,
+    );
+
+    const restChildren = filterChildren(children, [
+      WizardSubComponentProperties.Footer,
+    ]);
+
+    /**
+     * NB: We're intentionally do _not_ wrap the WizardStep` component in a container element.
+     * This is done to ensure the Wizard is flexible, and can be rendered in any containing layout.
+     */
+    return (
+      <WizardStepProvider
+        stepId={stepId}
+        requiresAcknowledgement={requiresAcknowledgement}
+      >
+        {restChildren}
+        {footerChild}
+      </WizardStepProvider>
+    );
+  },
+  {
+    displayName: 'WizardStep',
+    key: WizardSubComponentProperties.Step,
+  },
+);
diff --git a/packages/wizard/src/WizardStep/WizardStep.types.ts b/packages/wizard/src/WizardStep/WizardStep.types.ts
new file mode 100644
index 0000000000..a3e609731a
--- /dev/null
+++ b/packages/wizard/src/WizardStep/WizardStep.types.ts
@@ -0,0 +1,8 @@
+export interface WizardStepProps extends React.PropsWithChildren<{}> {
+  /**
+   * Defines whether some action in Step must be taken by the user before enabling the primary action button
+   *
+   * @default false
+   */
+  requiresAcknowledgement?: boolean;
+}
diff --git a/packages/wizard/src/WizardStep/WizardStepContext.tsx b/packages/wizard/src/WizardStep/WizardStepContext.tsx
new file mode 100644
index 0000000000..b16d516074
--- /dev/null
+++ b/packages/wizard/src/WizardStep/WizardStepContext.tsx
@@ -0,0 +1,47 @@
+import React, {
+  createContext,
+  Dispatch,
+  PropsWithChildren,
+  SetStateAction,
+  useContext,
+  useState,
+} from 'react';
+
+export interface WizardStepContextData {
+  stepId: string;
+  requiresAcknowledgement: boolean;
+  isAcknowledged: boolean;
+  setAcknowledged: Dispatch<SetStateAction<boolean>>;
+}
+
+export const WizardStepContext = createContext<WizardStepContextData>({
+  stepId: '',
+  requiresAcknowledgement: false,
+  isAcknowledged: false,
+  setAcknowledged: () => {},
+});
+
+export const WizardStepProvider = ({
+  stepId,
+  requiresAcknowledgement,
+  children,
+}: PropsWithChildren<
+  Omit<WizardStepContextData, 'isAcknowledged' | 'setAcknowledged'>
+>) => {
+  const [isAcknowledged, setAcknowledged] = useState(false);
+
+  return (
+    <WizardStepContext.Provider
+      value={{
+        stepId,
+        requiresAcknowledgement,
+        isAcknowledged,
+        setAcknowledged,
+      }}
+    >
+      {children}
+    </WizardStepContext.Provider>
+  );
+};
+
+export const useWizardStepContext = () => useContext(WizardStepContext);
diff --git a/packages/wizard/src/WizardStep/index.ts b/packages/wizard/src/WizardStep/index.ts
new file mode 100644
index 0000000000..6ef4b499f6
--- /dev/null
+++ b/packages/wizard/src/WizardStep/index.ts
@@ -0,0 +1,3 @@
+export { WizardStep } from './WizardStep';
+export { type WizardStepProps } from './WizardStep.types';
+export { useWizardStepContext } from './WizardStepContext';
diff --git a/packages/wizard/src/constants.ts b/packages/wizard/src/constants.ts
new file mode 100644
index 0000000000..38d0121456
--- /dev/null
+++ b/packages/wizard/src/constants.ts
@@ -0,0 +1,6 @@
+export const WizardSubComponentProperties = {
+  Step: 'isWizardStep',
+  Footer: 'isWizardFooter',
+} as const;
+export type WizardSubComponentProperties =
+  (typeof WizardSubComponentProperties)[keyof typeof WizardSubComponentProperties];
diff --git a/packages/wizard/src/index.ts b/packages/wizard/src/index.ts
new file mode 100644
index 0000000000..1c370edbab
--- /dev/null
+++ b/packages/wizard/src/index.ts
@@ -0,0 +1,9 @@
+export { Wizard, type WizardProps } from './Wizard';
+export {
+  useWizardContext,
+  WizardContext,
+  type WizardContextData,
+  WizardProvider,
+} from './WizardContext';
+export { type WizardFooterProps } from './WizardFooter';
+export { useWizardStepContext, type WizardStepProps } from './WizardStep';
diff --git a/packages/wizard/src/testing/getTestUtils.spec.tsx b/packages/wizard/src/testing/getTestUtils.spec.tsx
new file mode 100644
index 0000000000..74dfa04a87
--- /dev/null
+++ b/packages/wizard/src/testing/getTestUtils.spec.tsx
@@ -0,0 +1,284 @@
+import React from 'react';
+import { render } from '@testing-library/react';
+
+import { Wizard } from '../Wizard';
+
+import { getTestUtils } from './getTestUtils';
+
+describe('packages/wizard/getTestUtils', () => {
+  describe('Footer utils', () => {
+    test('getFooter returns the correct footer element', () => {
+      render(
+        <Wizard>
+          <Wizard.Step>
+            <div>Step 1</div>
+            <Wizard.Footer
+              primaryButtonProps={{ children: 'Next Step' }}
+              cancelButtonProps={{ children: 'Cancel Action' }}
+            />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { getFooter } = getTestUtils();
+      const footer = getFooter();
+      expect(footer).toBeInTheDocument();
+      expect(footer.tagName).toBe('FOOTER');
+      expect(footer).toHaveAttribute('data-testid', 'lg-wizard-footer');
+      // Verify it contains the buttons
+      expect(footer).toHaveTextContent('Next Step');
+      expect(footer).toHaveTextContent('Cancel Action');
+    });
+
+    test('queryFooter returns null when footer is not present', () => {
+      render(<div>No wizard here</div>);
+
+      const { queryFooter } = getTestUtils();
+      const footer = queryFooter();
+      expect(footer).not.toBeInTheDocument();
+    });
+
+    test('findFooter finds the footer element', async () => {
+      render(
+        <Wizard>
+          <Wizard.Step>
+            <div>Step 1</div>
+            <Wizard.Footer primaryButtonProps={{ children: 'Submit' }} />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { findFooter } = getTestUtils();
+      const footer = await findFooter();
+      expect(footer).toBeInTheDocument();
+      expect(footer).toHaveTextContent('Submit');
+    });
+  });
+
+  describe('Button utils', () => {
+    test('getPrimaryButton returns the correct primary button element', () => {
+      render(
+        <Wizard>
+          <Wizard.Step>
+            <div>Step 1</div>
+            <Wizard.Footer primaryButtonProps={{ children: 'Next Step' }} />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { getPrimaryButton } = getTestUtils();
+      const primaryButton = getPrimaryButton();
+      expect(primaryButton).toBeInTheDocument();
+      expect(primaryButton.tagName).toBe('BUTTON');
+      expect(primaryButton).toHaveAttribute(
+        'data-testid',
+        'lg-wizard-footer-primary_button',
+      );
+      expect(primaryButton).toHaveTextContent('Next Step');
+    });
+
+    test('queryPrimaryButton returns null when the primary button is not present', () => {
+      render(<div>No wizard here</div>);
+
+      const { queryPrimaryButton } = getTestUtils();
+      const button = queryPrimaryButton();
+      expect(button).not.toBeInTheDocument();
+    });
+
+    test('findPrimaryButton finds the primary button element', async () => {
+      render(
+        <Wizard>
+          <Wizard.Step>
+            <div>Step 1</div>
+            <Wizard.Footer primaryButtonProps={{ children: 'Continue' }} />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { findPrimaryButton } = getTestUtils();
+      const button = await findPrimaryButton();
+      expect(button).toBeInTheDocument();
+      expect(button).toHaveTextContent('Continue');
+    });
+
+    test('isPrimaryButtonDisabled returns true when the primary button is disabled', () => {
+      render(
+        <Wizard>
+          <Wizard.Step>
+            <div>Step 1</div>
+            <Wizard.Footer
+              primaryButtonProps={{ children: 'Next', disabled: true }}
+            />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { isPrimaryButtonDisabled } = getTestUtils();
+      expect(isPrimaryButtonDisabled()).toBe(true);
+    });
+
+    test('isPrimaryButtonDisabled returns false when the primary button is enabled', () => {
+      render(
+        <Wizard>
+          <Wizard.Step>
+            <div>Step 1</div>
+            <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { isPrimaryButtonDisabled } = getTestUtils();
+      expect(isPrimaryButtonDisabled()).toBe(false);
+    });
+
+    test('getBackButton returns the correct back button element', () => {
+      render(
+        <Wizard activeStep={1}>
+          <Wizard.Step>
+            <div>Step 1</div>
+            <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+          </Wizard.Step>
+          <Wizard.Step>
+            <div>Step 2</div>
+            <Wizard.Footer
+              backButtonProps={{ children: 'Go Back' }}
+              primaryButtonProps={{ children: 'Finish' }}
+            />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { getBackButton } = getTestUtils();
+      const backButton = getBackButton();
+      expect(backButton).toBeInTheDocument();
+      expect(backButton.tagName).toBe('BUTTON');
+      expect(backButton).toHaveAttribute(
+        'data-testid',
+        'lg-wizard-footer-back_button',
+      );
+      expect(backButton).toHaveTextContent('Go Back');
+    });
+
+    test('queryBackButton returns null when back button is not present', () => {
+      render(
+        <Wizard>
+          <Wizard.Step>
+            <div>Step 1</div>
+            <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { queryBackButton } = getTestUtils();
+      const button = queryBackButton();
+      expect(button).not.toBeInTheDocument();
+    });
+
+    test('findBackButton finds the back button element', async () => {
+      render(
+        <Wizard activeStep={1}>
+          <Wizard.Step>
+            <div>Step 1</div>
+            <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+          </Wizard.Step>
+          <Wizard.Step>
+            <div>Step 2</div>
+            <Wizard.Footer
+              backButtonProps={{ children: 'Previous' }}
+              primaryButtonProps={{ children: 'Next' }}
+            />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { findBackButton } = getTestUtils();
+      const button = await findBackButton();
+      expect(button).toBeInTheDocument();
+      expect(button).toHaveTextContent('Previous');
+    });
+
+    test('getCancelButton returns the correct cancel button element', () => {
+      render(
+        <Wizard>
+          <Wizard.Step>
+            <div>Step 1</div>
+            <Wizard.Footer
+              cancelButtonProps={{ children: 'Cancel Process' }}
+              primaryButtonProps={{ children: 'Next' }}
+            />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { getCancelButton } = getTestUtils();
+      const cancelButton = getCancelButton();
+      expect(cancelButton).toBeInTheDocument();
+      expect(cancelButton.tagName).toBe('BUTTON');
+      expect(cancelButton).toHaveAttribute(
+        'data-testid',
+        'lg-wizard-footer-cancel_button',
+      );
+      expect(cancelButton).toHaveTextContent('Cancel Process');
+    });
+
+    test('queryCancelButton returns the default cancel button if no props are provided', () => {
+      render(
+        <Wizard>
+          <Wizard.Step>
+            <div>Step 1</div>
+            <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { queryCancelButton } = getTestUtils();
+      const button = queryCancelButton();
+      expect(button).toBeInTheDocument();
+    });
+
+    test('findCancelButton finds the cancel button element', async () => {
+      render(
+        <Wizard>
+          <Wizard.Step>
+            <div>Step 1</div>
+            <Wizard.Footer
+              cancelButtonProps={{ children: 'Abort' }}
+              primaryButtonProps={{ children: 'Next' }}
+            />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { findCancelButton } = getTestUtils();
+      const button = await findCancelButton();
+      expect(button).toBeInTheDocument();
+      expect(button).toHaveTextContent('Abort');
+    });
+  });
+
+  describe('with custom lgId', () => {
+    test('uses custom lgId when provided', () => {
+      render(
+        <Wizard data-lgid="lg-custom-wizard">
+          <Wizard.Step>
+            <div data-testid="custom-content">Step 1</div>
+            <Wizard.Footer primaryButtonProps={{ children: 'Next' }} />
+          </Wizard.Step>
+        </Wizard>,
+      );
+
+      const { getFooter, getPrimaryButton } = getTestUtils('lg-custom-wizard');
+
+      const footer = getFooter();
+      expect(footer).toBeInTheDocument();
+      expect(footer).toHaveAttribute('data-testid', 'lg-custom-wizard-footer');
+
+      const button = getPrimaryButton();
+      expect(button).toBeInTheDocument();
+      expect(button).toHaveAttribute(
+        'data-testid',
+        'lg-custom-wizard-footer-primary_button',
+      );
+    });
+  });
+});
diff --git a/packages/wizard/src/testing/getTestUtils.tsx b/packages/wizard/src/testing/getTestUtils.tsx
new file mode 100644
index 0000000000..6dd5b53162
--- /dev/null
+++ b/packages/wizard/src/testing/getTestUtils.tsx
@@ -0,0 +1,127 @@
+import { findByLgId, getByLgId, queryByLgId } from '@lg-tools/test-harnesses';
+
+import { getTestUtils as getButtonUtils } from '@leafygreen-ui/button/testing';
+import { LgIdString } from '@leafygreen-ui/lib';
+
+import { DEFAULT_LGID_ROOT, getLgIds } from '../utils/getLgIds';
+
+import { TestUtilsReturnType } from './getTestUtils.types';
+
+export const getTestUtils = (
+  lgId: LgIdString = DEFAULT_LGID_ROOT,
+): TestUtilsReturnType => {
+  const lgIds = getLgIds(lgId);
+
+  /**
+   * @returns a promise that resolves to the WizardFooter element using the `data-lgid` data attribute.
+   * The promise is rejected if no elements match or if more than one match is found.
+   */
+  const findFooter = () => findByLgId!<HTMLElement>(lgIds.footer);
+
+  /**
+   * @returns the WizardFooter element using the `data-testid` data attribute.
+   * Will throw if no elements match or if more than one match is found.
+   */
+  const getFooter = () => getByLgId!<HTMLElement>(lgIds.footer);
+
+  /**
+   * @returns the WizardFooter element using the `data-testid` data attribute or `null` if no elements match.
+   * Will throw if more than one match is found.
+   */
+  const queryFooter = () => queryByLgId!<HTMLElement>(lgIds.footer);
+
+  /**
+   * @returns the primary button element using the `data-testid` data attribute.
+   * Will throw if no elements match or if more than one match is found.
+   */
+  const getPrimaryButton = getButtonUtils<HTMLButtonElement>(
+    lgIds.footerPrimaryButton,
+  ).getButton;
+
+  /**
+   * @returns the primary button element using the `data-testid` data attribute or `null` if no elements match.
+   * Will throw if more than one match is found.
+   */
+  const queryPrimaryButton = getButtonUtils<HTMLButtonElement>(
+    lgIds.footerPrimaryButton,
+  ).queryButton;
+
+  /**
+   * @returns a promise that resolves to the primary button element using the `data-testid` data attribute.
+   * The promise is rejected if no elements match or if more than one match is found.
+   */
+  const findPrimaryButton = getButtonUtils<HTMLButtonElement>(
+    lgIds.footerPrimaryButton,
+  ).findButton;
+
+  /**
+   * @returns whether the primary button is disabled (via `aria-disabled`)
+   */
+  const isPrimaryButtonDisabled = getButtonUtils<HTMLButtonElement>(
+    lgIds.footerPrimaryButton,
+  ).isDisabled;
+
+  /**
+   * @returns the back button element using the `data-testid` data attribute.
+   * Will throw if no elements match or if more than one match is found.
+   */
+  const getBackButton = getButtonUtils<HTMLButtonElement>(
+    lgIds.footerBackButton,
+  ).getButton;
+
+  /**
+   * @returns the back button element using the `data-testid` data attribute or `null` if no elements match.
+   * Will throw if more than one match is found.
+   */
+  const queryBackButton = getButtonUtils<HTMLButtonElement>(
+    lgIds.footerBackButton,
+  ).queryButton;
+
+  /**
+   * @returns a promise that resolves to the back button element using the `data-testid` data attribute.
+   * The promise is rejected if no elements match or if more than one match is found.
+   */
+  const findBackButton = getButtonUtils<HTMLButtonElement>(
+    lgIds.footerBackButton,
+  ).findButton;
+
+  /**
+   * @returns the cancel button element using the `data-testid` data attribute.
+   * Will throw if no elements match or if more than one match is found.
+   */
+  const getCancelButton = getButtonUtils<HTMLButtonElement>(
+    lgIds.footerCancelButton,
+  ).getButton;
+
+  /**
+   * @returns the cancel button element using the `data-testid` data attribute or `null` if no elements match.
+   * Will throw if more than one match is found.
+   */
+  const queryCancelButton = getButtonUtils<HTMLButtonElement>(
+    lgIds.footerCancelButton,
+  ).queryButton;
+
+  /**
+   * @returns a promise that resolves to the cancel button element using the `data-testid` data attribute.
+   * The promise is rejected if no elements match or if more than one match is found.
+   */
+  const findCancelButton = getButtonUtils<HTMLButtonElement>(
+    lgIds.footerCancelButton,
+  ).findButton;
+
+  return {
+    findFooter,
+    getFooter,
+    queryFooter,
+    getPrimaryButton,
+    queryPrimaryButton,
+    findPrimaryButton,
+    isPrimaryButtonDisabled,
+    getBackButton,
+    queryBackButton,
+    findBackButton,
+    getCancelButton,
+    queryCancelButton,
+    findCancelButton,
+  };
+};
diff --git a/packages/wizard/src/testing/getTestUtils.types.ts b/packages/wizard/src/testing/getTestUtils.types.ts
new file mode 100644
index 0000000000..d69a436de8
--- /dev/null
+++ b/packages/wizard/src/testing/getTestUtils.types.ts
@@ -0,0 +1,24 @@
+import { type GetTestUtilsReturnType as ButtonTestUtilsReturnType } from '@leafygreen-ui/button/testing';
+
+export interface TestUtilsReturnType {
+  // Footer utils
+  findFooter: () => Promise<HTMLElement>;
+  getFooter: () => HTMLElement;
+  queryFooter: () => HTMLElement | null;
+
+  // Primary Button utils
+  getPrimaryButton: ButtonTestUtilsReturnType<HTMLButtonElement>['getButton'];
+  queryPrimaryButton: ButtonTestUtilsReturnType<HTMLButtonElement>['queryButton'];
+  findPrimaryButton: ButtonTestUtilsReturnType<HTMLButtonElement>['findButton'];
+  isPrimaryButtonDisabled: ButtonTestUtilsReturnType<HTMLButtonElement>['isDisabled'];
+
+  // Back Button utils
+  getBackButton: ButtonTestUtilsReturnType<HTMLButtonElement>['getButton'];
+  queryBackButton: ButtonTestUtilsReturnType<HTMLButtonElement>['queryButton'];
+  findBackButton: ButtonTestUtilsReturnType<HTMLButtonElement>['findButton'];
+
+  // Cancel Button utils
+  getCancelButton: ButtonTestUtilsReturnType<HTMLButtonElement>['getButton'];
+  queryCancelButton: ButtonTestUtilsReturnType<HTMLButtonElement>['queryButton'];
+  findCancelButton: ButtonTestUtilsReturnType<HTMLButtonElement>['findButton'];
+}
diff --git a/packages/wizard/src/testing/index.ts b/packages/wizard/src/testing/index.ts
new file mode 100644
index 0000000000..4c102995fa
--- /dev/null
+++ b/packages/wizard/src/testing/index.ts
@@ -0,0 +1,2 @@
+export { getTestUtils } from './getTestUtils';
+export { type TestUtilsReturnType } from './getTestUtils.types';
diff --git a/packages/wizard/src/utils/getLgIds.ts b/packages/wizard/src/utils/getLgIds.ts
new file mode 100644
index 0000000000..565a9db506
--- /dev/null
+++ b/packages/wizard/src/utils/getLgIds.ts
@@ -0,0 +1,16 @@
+import { LgIdString } from '@leafygreen-ui/lib';
+
+export const DEFAULT_LGID_ROOT = 'lg-wizard';
+
+export const getLgIds = (root: LgIdString = DEFAULT_LGID_ROOT) => {
+  const ids = {
+    step: `${root}-step`,
+    footer: `${root}-footer`,
+    footerPrimaryButton: `${root}-footer-primary_button`,
+    footerBackButton: `${root}-footer-back_button`,
+    footerCancelButton: `${root}-footer-cancel_button`,
+  } as const;
+  return ids;
+};
+
+export type GetLgIdsReturnType = ReturnType<typeof getLgIds>;
diff --git a/packages/wizard/tsconfig.json b/packages/wizard/tsconfig.json
new file mode 100644
index 0000000000..693201d7c6
--- /dev/null
+++ b/packages/wizard/tsconfig.json
@@ -0,0 +1,61 @@
+{
+  "extends": "@lg-tools/build/config/package.tsconfig.json",
+   "compilerOptions": {
+    "paths": {
+      "@leafygreen-ui/icon/dist/*": ["../icon/src/generated/*"],
+      "@leafygreen-ui/*": ["../*/src"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["**/*.spec.*", "**/*.stories.*"],
+  "references": [
+    {
+      "path": "../button"
+    },
+    {
+      "path": "../badge"
+    },
+    {
+      "path": "../card"
+    },
+    {
+      "path": "../checkbox"
+    },
+    {
+      "path": "../compound-component"
+    },
+    {
+      "path": "../emotion"
+    },
+    {
+      "path": "../expandable-card"
+    },
+    {
+      "path": "../form-footer"
+    },
+    {
+      "path": "../icon"
+    },
+    {
+      "path": "../lib"
+    },
+    {
+      "path": "../loading-indicator"
+    },
+    {
+      "path": "../segmented-control"
+    },
+    {
+      "path": "../skeleton-loader"
+    },
+    {
+      "path": "../table"
+    },
+    {
+      "path": "../typography"
+    },
+    {
+      "path": "../../tools/test-harnesses"
+    }
+  ]
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index e048eb7d6e..8747f81e5f 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -3813,6 +3813,70 @@ importers:
         specifier: workspace:^
         version: link:../../tools/storybook-utils
 
+  packages/wizard:
+    dependencies:
+      '@leafygreen-ui/button':
+        specifier: workspace:^
+        version: link:../button
+      '@leafygreen-ui/compound-component':
+        specifier: workspace:^
+        version: link:../compound-component
+      '@leafygreen-ui/emotion':
+        specifier: workspace:^
+        version: link:../emotion
+      '@leafygreen-ui/form-footer':
+        specifier: workspace:^
+        version: link:../form-footer
+      '@leafygreen-ui/hooks':
+        specifier: workspace:^
+        version: link:../hooks
+      '@leafygreen-ui/lib':
+        specifier: workspace:^
+        version: link:../lib
+      '@leafygreen-ui/polymorphic':
+        specifier: workspace:^
+        version: link:../polymorphic
+      '@leafygreen-ui/tokens':
+        specifier: workspace:^
+        version: link:../tokens
+      '@lg-tools/test-harnesses':
+        specifier: workspace:^
+        version: link:../../tools/test-harnesses
+    devDependencies:
+      '@faker-js/faker':
+        specifier: ^8.0.0
+        version: 8.0.2
+      '@leafygreen-ui/badge':
+        specifier: workspace:^
+        version: link:../badge
+      '@leafygreen-ui/banner':
+        specifier: workspace:^
+        version: link:../banner
+      '@leafygreen-ui/card':
+        specifier: workspace:^
+        version: link:../card
+      '@leafygreen-ui/checkbox':
+        specifier: workspace:^
+        version: link:../checkbox
+      '@leafygreen-ui/expandable-card':
+        specifier: workspace:^
+        version: link:../expandable-card
+      '@leafygreen-ui/icon':
+        specifier: workspace:^
+        version: link:../icon
+      '@leafygreen-ui/loading-indicator':
+        specifier: workspace:^
+        version: link:../loading-indicator
+      '@leafygreen-ui/segmented-control':
+        specifier: workspace:^
+        version: link:../segmented-control
+      '@leafygreen-ui/skeleton-loader':
+        specifier: workspace:^
+        version: link:../skeleton-loader
+      '@leafygreen-ui/typography':
+        specifier: workspace:^
+        version: link:../typography
+
   tools/build:
     dependencies:
       '@babel/core':
diff --git a/tools/install/src/ALL_PACKAGES.ts b/tools/install/src/ALL_PACKAGES.ts
index 1306b5f615..c2964f5cfc 100644
--- a/tools/install/src/ALL_PACKAGES.ts
+++ b/tools/install/src/ALL_PACKAGES.ts
@@ -79,6 +79,7 @@ export const ALL_PACKAGES = [
   '@leafygreen-ui/tooltip',
   '@leafygreen-ui/typography',
   '@leafygreen-ui/vertical-stepper',
+  '@leafygreen-ui/wizard',
   '@lg-charts/chart-card',
   '@lg-charts/colors',
   '@lg-charts/core',