diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index dd654a1dd48..356afcb86ce 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -89,6 +89,7 @@ repos:
         args:
           - --color
           - --fix
+          - --no-warn-ignored
         verbose: true
         types: [javascript]
         language: node
diff --git a/audit/.gitignore b/audit/.gitignore
new file mode 100644
index 00000000000..70158bba4e8
--- /dev/null
+++ b/audit/.gitignore
@@ -0,0 +1,3 @@
+**/**.DS_Store
+**/**.pyc
+__pycache__/
diff --git a/audit/README.md b/audit/README.md
new file mode 100644
index 00000000000..1d25363593b
--- /dev/null
+++ b/audit/README.md
@@ -0,0 +1,497 @@
+# Audit module — technical documentation
+
+This module provides a **generic audit/checklist engine** with a **dashboard-driven
+workflow** to:
+
+- design an audit (domain → sections → questions),
+- link the audit to auditable items (“targets”),
+- conduct audits and store the result as immutable-ish “snapshots” (with scoring,
+  comments, and optional images),
+- browse results with search + pagination and a summary view.
+
+The backend is standard Odoo ORM models; the UI entry point is an Odoo backend client
+action implemented in Owl/JS.
+
+## Contents
+
+- [Module summary](#module-summary)
+- [Concepts](#concepts)
+- [Data model](#data-model)
+- [Security and access control](#security-and-access-control)
+- [Audit lifecycle](#audit-lifecycle)
+- [Scoring](#scoring)
+- [UI / dashboard implementation](#ui--dashboard-implementation)
+- [Backend API used by the dashboard](#backend-api-used-by-the-dashboard)
+- [Configuration constants](#configuration-constants)
+- [Operational notes and known constraints](#operational-notes-and-known-constraints)
+- [Troubleshooting](#troubleshooting)
+
+## Module summary
+
+- **Module name**: `audit`
+- **Location**: `src/internal_tools/audit/`
+- **Manifest**: `src/internal_tools/audit/__manifest__.py`
+- **Depends on**:
+  - `base`
+  - `web`
+- **Backend assets**: all files under `audit/static/src/**/*` are included in
+  `web.assets_backend`.
+
+## Concepts
+
+- **Domain** (`audit.domain`): a _type/class_ of audit (e.g. “Retail Store H&S”,
+  “Warehouse Safety”, “ISO 27001”).
+- **Target** (`audit.target`): a _specific auditable item_ within a domain (e.g. “Store
+  #12”, “Warehouse Auckland”).
+- **Section** (`audit.section`): groups questions within a domain (e.g. “Fire safety”,
+  “Staff training”).
+- **Question** (`audit.question`): a question template (prompt + answer type).
+- **Inspector** (`audit.inspector`): the person conducting the audit (can be linked to
+  `res.partner`).
+- **Team** (`audit.team`): groups inspectors; leaders can see team members’ snapshots.
+- **Snapshot** (`audit.snapshot`): a conducted audit instance for a target at a point in
+  time.
+- **Snapshot Section** (`audit.snapshot_section`): a copy of each section template
+  stored on a snapshot.
+- **Snapshot Question** (`audit.snapshot_question`): a copy of each question template
+  stored on a snapshot, plus answers/comments/images.
+
+## Data model
+
+### `audit.domain` (Audit Domain)
+
+- **Purpose**: defines an audit “template” boundary (sections, questions, and allowed
+  targets).
+- **Key fields**:
+  - `name` (Text)
+  - `section_ids` (One2many → `audit.section`)
+  - `target_ids` (One2many → `audit.target` via `audit.target.domain_id`) —
+    legacy/simple linkage
+  - `target_rel_ids` (Many2many → `audit.target` via relation table
+    `audit_domain_target_rel`) — primary linkage used by UI
+  - `all_target_rel_ids` (computed/inverse Many2many) — merges `target_ids` +
+    `target_rel_ids` for a unified UI field
+  - **Key methods**:
+  - `action_duplicate_domain()`: duplicates a domain and deep-copies sections +
+    questions; links existing targets to the new domain.
+
+### `audit.section` (Audit Section)
+
+- **Purpose**: groups question templates under a domain.
+- **Key fields**:
+  - `name` (Text)
+  - `domain_id` (Many2one → `audit.domain`, required)
+  - `question_ids` (One2many → `audit.question`)
+
+### `audit.question` (Audit Question Template)
+
+- **Purpose**: defines a question prompt and its answer type.
+- **Key fields**:
+  - `prompt` (Text)
+  - `answer_type` (Selection): `boolean` | `integer` | `float`
+  - `section_id` (Many2one → `audit.section`, required)
+  - `name` (computed from `prompt`) — used as the record display name
+
+### `audit.target` (Auditable Target)
+
+- **Purpose**: the entity being audited.
+- **Key fields**:
+  - `name` (Text)
+  - `domain_id` (Many2one → `audit.domain`, optional)
+  - `domain_rel_ids` (Many2many → `audit.domain` via `audit_domain_target_rel`)
+  - `all_domain_rel_ids` (computed/inverse Many2many) — merges `domain_id` +
+    `domain_rel_ids`
+  - `snapshot_ids` (One2many → `audit.snapshot`)
+  - **Key methods**:
+  - `merge()`: consolidates targets with the same name by re-pointing snapshots and
+    deleting duplicates.
+
+### `audit.domain_target_rel` (Domain ↔ Target relation)
+
+- **Purpose**: intermediate model/table used by the domain/target Many2many
+  relationship.
+- **Key fields**:
+  - `domain_id` (Many2one → `audit.domain`, required)
+  - `target_id` (Many2one → `audit.target`, required)
+
+### `audit.inspector` (Inspector)
+
+- **Purpose**: identifies the auditor/inspector/manager who conducts a snapshot.
+- **Key fields**:
+  - `name` (Char, required)
+  - `partner_id` (Many2one → `res.partner`, optional)
+  - `inspector_email` (related → `partner_id.email`, editable)
+  - `forename`, `surname` (Char)
+  - `active` (Boolean)
+  - `snapshot_ids` (One2many → `audit.snapshot`)
+  - `team_ids` (Many2many → `audit.team`)
+
+### `audit.team` (Audit Team)
+
+- **Purpose**: groups inspectors and defines leadership visibility.
+- **Key fields**:
+  - `name` (Char, required)
+  - `team_member_ids` (Many2many → `audit.inspector`)
+  - `team_leader_ids` (Many2many → `audit.inspector`)
+
+### `audit.snapshot` (Audit Snapshot)
+
+- **Purpose**: represents one conducted audit event for a target.
+- **Key fields**:
+  - `domain_id` (Many2one → `audit.domain`)
+  - `target_id` (Many2one → `audit.target`, required)
+  - `inspector_id` (Many2one → `audit.inspector`, required)
+  - `date_conducted` (Datetime, default: now)
+  - `snapshot_section_ids` (One2many → `audit.snapshot_section`, required)
+  - `locked` (Boolean): UI uses this to prevent “submit” again; backend does not
+    strictly enforce immutability
+  - `active` (Boolean): used for archive/unarchive semantics
+  - `percentage_score` (Float, computed): overall score in decimal form \(0.00–1.00\)
+  - `questions_with_comments` (Integer, computed): count of snapshot questions with
+    comments (computed only when locked)
+  - `team_id` (Many2one → `audit.team`, optional)
+  - **Creation behavior**:
+  - `create()` is overridden to auto-generate `audit.snapshot_section` records for every
+    `audit.section` in the chosen domain and `audit.snapshot_question` records for every
+    `audit.question` in each section.
+
+### `audit.snapshot_section` (Snapshot Section)
+
+- **Purpose**: stores a copy of the domain’s section structure at the time of snapshot
+  creation.
+- **Key fields**:
+  - `name` (Text)
+  - `original_section_id` (Many2one → `audit.section`)
+  - `domain_id` (Many2one → `audit.domain`, required)
+  - `snapshot_id` (Many2one → `audit.snapshot`)
+  - `snapshot_question_ids` (One2many → `audit.snapshot_question`)
+  - `maximum_section_score`, `actual_section_score`, `percentage_section_score`
+    (computed)
+
+### `audit.snapshot_question` (Snapshot Question)
+
+- **Purpose**: stores a copy of each question, plus answer/comment/image fields for the
+  specific snapshot.
+- **Key fields**:
+  - `snapshot_id` (Many2one → `audit.snapshot`)
+  - `snapshot_section_id` (Many2one → `audit.snapshot_section`, required)
+  - `original_question_id` (Many2one → `audit.question`)
+  - `prompt` (Text)
+  - `answer_type` (Char)
+  - Answer fields (only one is expected to be used per record):
+    - `answer_yn` (Selection): `"0"`/`"1"`
+    - `answer_star` (Selection): `"1"`..`"4"`
+    - `answer_perc` (Float): \(0–100\)
+  - `applicable` (Boolean, default `True`): excludes the question from snapshot
+    maximum/actual scoring when `False`
+  - `comment` (Text)
+  - `image` (Image): can be set from the dashboard using a base64 data URL payload
+  - `value` (Float, computed): normalized score used by snapshot scoring
+  - **Key methods**:
+  - `toggle_not_applicable(id)`: flips `applicable` and returns `{id, applicable}` (used
+    by the dashboard)
+  - `write(vals)`: if `image` is provided as `data:<mime>;base64,<payload>`, it strips
+    the prefix and stores only the base64 payload.
+
+## Security and access control
+
+### Groups
+
+- **Module category**: `Audit` (defined in `security/security.xml`)
+- **Primary group**: `audit.group_audit_permission`
+  - implies `base.group_user`
+  - access rules are primarily done via standard model access and custom menu actions
+
+### Model access
+
+`security/ir.model.access.csv` grants full CRUD to `audit.group_audit_permission` for:
+
+- `audit.domain`, `audit.section`, `audit.question`
+- `audit.target`, `audit.domain_target_rel`
+- `audit.inspector`, `audit.team`
+- `audit.snapshot`, `audit.snapshot_section`, `audit.snapshot_question`
+- `audit.menu.access.control` (Transient model used by server actions)
+
+### Menu access control (server actions)
+
+The menus for Teams/Inspectors/Snapshots/Snapshot Sections/Snapshot Questions are wired
+to **server actions** (`views/actions.xml`) that call methods on
+`audit.menu.access.control`.
+
+Those methods return an `ir.actions.act_window` with a dynamic **domain**:
+
+- **Admin users** (`base.group_system`): see everything.
+- **Team leaders**: see records for inspectors in teams they lead.
+- **Non-leaders**: see only their own records.
+
+Important: this logic relies on an “inspector ↔ user” link. Parts of the implementation
+reference `audit.inspector.res_user_id`, which is not currently defined on
+`audit.inspector` in this module. See
+[Operational notes and known constraints](#operational-notes-and-known-constraints).
+
+## Audit lifecycle
+
+### 1) Design an audit (Domain → Sections → Questions)
+
+- Create an `audit.domain`.
+- Add `audit.section` records.
+- Add `audit.question` records to each section, choosing an answer type:
+  - boolean (Yes/No)
+  - integer (1–4 stars)
+  - float (0–100% slider)
+- Optionally duplicate an existing domain via **Duplicate** on the domain form
+  (deep-copies sections + questions).
+
+### 2) Define auditable items (Targets)
+
+- Create `audit.target` records.
+- Link targets to domains using the `audit_domain_target_rel` relationship (exposed in
+  the domain “Targets in Domain” page and target “Linked Domains” fields).
+
+### 3) Set up inspectors and teams
+
+- Create `audit.inspector` records (often linked to `res.partner` via `partner_id`).
+- Create `audit.team` records and assign members/leaders.
+
+### 4) Conduct an audit (create a Snapshot)
+
+From **Audit Dashboard**:
+
+- Select domain → target → inspector.
+- Create the snapshot.
+
+The snapshot creation process copies the current audit design into the snapshot:
+
+- `audit.snapshot_section` rows are generated from `audit.section` rows for the domain.
+- `audit.snapshot_question` rows are generated from `audit.question` rows for each
+  section.
+
+### 5) Answer questions (auto-save)
+
+In the “View Questions” screen:
+
+- Each question renders an input based on `answer_type`:
+  - boolean → Yes/No dropdown
+  - integer → star rating dropdown (1–4)
+  - float → percentage slider (0–100)
+- Comments are saved immediately when edited.
+- Images can be uploaded; the dashboard sends a base64 data URL which the backend
+  stores.
+- A question can be toggled **Applicable / Excluded**; excluded questions are removed
+  from overall snapshot scoring.
+
+### 6) Submit the snapshot (lock)
+
+Submitting a snapshot sets `audit.snapshot.locked = True`.
+
+- The dashboard prevents double-submission and visually indicates locked snapshots.
+- The backend does not strictly block edits to locked snapshots; “locked” is currently
+  used as a workflow flag rather than a hard data integrity constraint.
+
+### 7) View summary
+
+For locked snapshots, the dashboard provides a Summary view that:
+
+- groups questions by section,
+- displays **only questions with comments**,
+- displays any stored images,
+- shows section scores and the overall snapshot score.
+
+## Scoring
+
+### Question-level score (`audit.snapshot_question.value`)
+
+Snapshot questions normalize their answer into a value in the range \(0.0–1.0\).
+
+Implementation (current):
+
+- boolean:
+  - `"1"` → \(1.0\)
+  - `"0"` → \(0.0\)
+- star rating:
+  - `"1"`..`"4"` → \(\text{stars}/4\) → \(0.25..1.0\)
+- percentage:
+  - `0..100` → \(\text{percent}/100\) → \(0.0..1.0\)
+
+Important: the compute currently adds all three components:
+
+\[ value = float(answer_yn) + \frac{float(answer_star)}{4} + \frac{answer_perc}{100} \]
+
+This works as intended **only if non-selected answer fields are empty-but-coercible to
+0**, and only one answer input is used per question (as enforced by the UI).
+
+### Snapshot overall score (`audit.snapshot.percentage_score`)
+
+- **Maximum score**: counts **applicable** snapshot questions, with a weight of 1 per
+  question.
+- **Actual score**: sum of `value` for **applicable** snapshot questions.
+- **Percentage score**: `round(actual_score / maximum_score, 2)` stored as a decimal
+  \(0.00–1.00\).
+
+The dashboard displays \(percentage_score \times 100\%\).
+
+### Pass/Fail threshold
+
+- Backend constant: `PASS_THRESHOLD = 0.85`
+- UI uses the same effective threshold (85%) when rendering PASS/FAIL in the snapshot
+  list.
+
+### Section scoring note
+
+`audit.snapshot_section` computes per-section scores, but the current implementation
+does **not** exclude `applicable = False` questions from section maximum/actual
+computations. Overall snapshot scoring does exclude them.
+
+## UI / dashboard implementation
+
+### Entry point (menu → client action)
+
+- Menu: `views/menus.xml` defines the top-level menu “Audit Dashboard”.
+- Action: `views/actions.xml` registers an `ir.actions.client` with tag
+  `audit.dashboard`.
+- Client action: `static/src/javascript_components/dashboard/dashboard.js` registers the
+  Owl component in the action registry.
+
+### Components
+
+- `AuditDashboard` (`dashboard.js`): router-like parent; switches between pages.
+- `SnapshotList` (`snapshot_list.js`): table of searched snapshots; provides buttons to
+  view questions and summary.
+- `CreateSnapShot` (`create_snapshot.js`): selects domain/target/inspector and creates a
+  snapshot.
+- `Snapshot` (`snapshot.js`): renders sections/questions and implements auto-save +
+  submission.
+- `SnapshotSummary` (`snapshot_summary.js`): summary of commented questions and images
+  for a locked snapshot.
+
+### Shared store
+
+`static/src/store.js` defines a reactive store used by the dashboard pages:
+
+- Search inputs: `searchText`, `searchDate`, `searchStatus`, `searchPage`
+- Results: `searchedSnapshots`, `numberOfPages`
+- `executeSearch()` calls the backend `audit.snapshot.custom_search()`
+- Pagination UI uses the store’s computed `visiblePages`
+
+## Backend API used by the dashboard
+
+The dashboard calls backend methods using the standard `orm` service (RPC to Odoo
+models).
+
+### Snapshot search
+
+- **Method**: `audit.snapshot.custom_search(search_string)`
+- **Called by**: `store.executeSearch()`
+- **Inputs**: `search_string` is JSON with keys:
+  - `searchText` (string)
+  - `searchDate` (string, date-like)
+  - `searchStatus` (`PASS`/`FAIL`)
+  - `searchPage` (int)
+  - **Output**: dict:
+  - `snapshots`: list of `search_read` dicts for `audit.snapshot`
+  - `numberOfPages`: int
+  - `newPageNumber`: int
+
+### Snapshot creation
+
+- **Method**: `audit.snapshot.create([vals])`
+- **Called by**: `createSnapshotInstance()` in `dashboard_helpers.js`
+- **Required fields** (enforced by backend override):
+  - `domain_id`
+  - `target_id`
+  - `inspector_id`
+- **Side effects**:
+  - Generates snapshot sections + snapshot questions from the current domain template.
+
+### Loading snapshot questions for display
+
+The frontend typically loads questions by:
+
+- reading the snapshot (for `snapshot_section_ids`),
+- then `searchRead` on `audit.snapshot_question` for
+  `snapshot_section_id in snapshot_section_ids`,
+- then grouping by `snapshot_section_id[1]` (section display name).
+
+For image thumbnails, the UI searches `ir.attachment` records for the
+`audit.snapshot_question.image` field and uses `/web/image/<attachment_id>` as a URL.
+
+### Auto-save answers/comments/images
+
+- **Method**: `audit.snapshot_question.write([id], {vals})`
+- **Called by**: `autoSaveQuestionChanges()` in `dashboard_helpers.js`
+- **Notes**:
+  - if `vals.image` is a base64 data URL, backend `write()` strips the prefix before
+    saving.
+
+### Mark question not applicable
+
+- **Method**: `audit.snapshot_question.toggle_not_applicable([id])`
+- **Called by**: `questionApplicable()` in `dashboard_helpers.js`
+- **Effect**: flips `applicable` and returns the new value.
+
+### Submit snapshot (lock)
+
+- **Method**: `audit.snapshot.write([snapshot_id], {vals: {locked: true}})`
+- **Called by**: `submit()` in `dashboard_helpers.js`
+
+## Configuration constants
+
+In `models/audit_snapshot.py`:
+
+- `PAGE_SIZE = 10`: number of snapshot rows per page returned by `custom_search()`
+- `PASS_THRESHOLD = 0.85`: pass/fail cutoff used by `custom_search()` filtering and the
+  list decorations
+
+## Operational notes and known constraints
+
+These are important when deploying or extending the module; they affect correctness
+and/or permissions.
+
+- **Inspector ↔ User linking is incomplete**
+  - Menu access control uses `audit.inspector.res_user_id`, but `audit.inspector` does
+    not define `res_user_id` in this module.
+  - Snapshot visibility in `audit.snapshot.snapshots_per_user()` tries to locate an
+    inspector by either `res_user_id` or `partner_id`; only `partner_id` exists here.
+  - Practical impact: non-admin users may see “no records” and/or menu actions may not
+    filter as expected unless your deployment adds this link elsewhere.
+
+- **Search fields are partially implemented**
+  - The frontend submits `searchDate`, but the backend does not filter by date.
+  - The backend attempts a `searchText` filter against a field named `search_text`,
+    which is not defined on `audit.snapshot` in this module.
+
+- **“Locked” is a workflow flag, not a hard constraint**
+  - UI disables the submit button and indicates locking state.
+  - Backend does not prevent `write()` on `audit.snapshot_question` (auto-save continues
+    to work even if locked).
+
+- **Section scoring differs from snapshot scoring**
+  - Snapshot scoring excludes `applicable = False`.
+  - Snapshot section scoring currently does not.
+
+- **Uniqueness constraints**
+  - Some models declare constraints using `models.Constraint(...)` instead of Odoo’s
+    standard `_sql_constraints`. Depending on your Odoo version/config, the uniqueness
+    guarantees described here may not be enforced at the database level.
+
+## Extending the module
+
+- **Add a new question answer type**
+  - Backend:
+    - update `audit.question.QUESTION_OPTIONS` in `models/audit_question.py`
+    - add fields and scoring logic to `audit.snapshot_question` in
+      `models/audit_snapshot.py`
+  - Frontend:
+    - update rendering and validation in
+      `static/src/javascript_components/dashboard/snapshot.js`
+    - update auto-save payload generation in
+      `static/src/javascript_components/dashboard/dashboard_helpers.js`
+
+- **Enforce immutability after submit**
+  - Add backend guards in `audit.snapshot_question.write()` and/or
+    `audit.snapshot.write()` to block edits when the parent snapshot is locked (except
+    for admin/system users).
+
+- **Make visibility rules robust**
+  - Add an explicit link from `audit.inspector` to `res.users` (e.g. `res_user_id`) and
+    standardize all access-control code to use the same link.
diff --git a/audit/__init__.py b/audit/__init__.py
new file mode 100644
index 00000000000..b4f7f97bf4e
--- /dev/null
+++ b/audit/__init__.py
@@ -0,0 +1,4 @@
+"""Audit addon: models and wizards."""
+
+from . import models
+from . import wizards
diff --git a/audit/__manifest__.py b/audit/__manifest__.py
new file mode 100644
index 00000000000..d91b7ff40ef
--- /dev/null
+++ b/audit/__manifest__.py
@@ -0,0 +1,28 @@
+# pylint: disable=missing-module-docstring,pointless-statement
+{
+    "name": "Audit",
+    "summary": (
+        "Generic audit and checklist engine: domains, targets, snapshots, "
+        "and team-based access control."
+    ),
+    "author": "AMV Limited, Odoo Community Association (OCA)",
+    "website": "https://github.com/OCA/server-tools",
+    "category": "Services",
+    "version": "19.0.1.0.0",
+    "license": "LGPL-3",
+    "application": True,
+    "depends": [
+        "base",
+        "web",
+    ],
+    "data": [
+        "security/security.xml",
+        "security/ir.model.access.csv",
+        "views/views.xml",
+        "views/actions.xml",
+        "views/menus.xml",
+    ],
+    "assets": {
+        "web.assets_backend": ["audit/static/src/**/*"],
+    },
+}
diff --git a/audit/models/__init__.py b/audit/models/__init__.py
new file mode 100644
index 00000000000..c3f1e9d88c3
--- /dev/null
+++ b/audit/models/__init__.py
@@ -0,0 +1,9 @@
+"""Module docstring for init file."""
+
+from . import audit_question
+from . import audit_section
+from . import audit_snapshot
+from . import audit_target
+from . import audit_domain
+from . import audit_team
+from . import audit_inspector
diff --git a/audit/models/audit_domain.py b/audit/models/audit_domain.py
new file mode 100644
index 00000000000..c1a5188dee4
--- /dev/null
+++ b/audit/models/audit_domain.py
@@ -0,0 +1,98 @@
+"""Classes and backend functionality for Audit module"""
+
+import logging
+import random
+
+from odoo import Command, api, fields, models
+
+_logger = logging.getLogger(__name__)
+
+
+# We can add things that can be audited here
+class Domain(models.Model):
+    """
+    Domain model: each audit has a unique domain.
+    This groups the kind of thing that can be audited, for example
+    retail stores or software security. Within a domain we audit individual records.
+    """
+
+    _name = "audit.domain"
+    _description = "Audit Domain"
+
+    # We should not let duplicate domains to be created
+    _name_uniq = models.Constraint(
+        "unique (name)",
+        "'Domain Name' must be unique, this domain name already exists.",
+    )
+
+    name = fields.Text()
+
+    target_ids = fields.One2many(
+        comodel_name="audit.target", inverse_name="domain_id", string="Audit Targets"
+    )
+
+    target_rel_ids = fields.Many2many(
+        comodel_name="audit.target",
+        relation="audit_domain_target_rel",
+        column1="domain_id",
+        column2="target_id",
+        string="Audit Targets (Many2many)",
+    )
+
+    section_ids = fields.One2many(
+        comodel_name="audit.section", inverse_name="domain_id", string="Audit Sections"
+    )
+
+    all_target_rel_ids = fields.Many2many(
+        comodel_name="audit.target",
+        compute="_compute_all_target_ids",
+        inverse="_inverse_all_target_ids",
+        string="All Targets",
+        store=False,  # Do not store since it's computed dynamically
+    )
+
+    @api.depends("target_ids", "target_rel_ids")
+    def _compute_all_target_ids(self):
+        """Compute a combined Many2many field of all targets (One2many + Many2many)"""
+        for record in self:
+            target_records = record.target_ids | record.target_rel_ids
+            record.all_target_rel_ids = target_records  # Assign merged targets
+
+    def _inverse_all_target_ids(self):
+        """Ensure new targets added via UI are linked to Many2many (`target_rel_ids`)"""
+        for record in self:
+            record.target_rel_ids = record.all_target_rel_ids
+
+    # Duplicate Audit Design all related section with questions
+    def action_duplicate_domain(self):
+        """Duplicate the audit domain and update Many2many relationships correctly."""
+        for record in self:
+            unique_key = random.randint(1, 100000)
+            # Temporary name until the user renames; domain names are unique.
+            new_domain = record.copy(
+                {"name": f"{record.name} - Duplicate_{unique_key}"}
+            )
+
+            # Duplicate Sections & Questions
+            section_mapping = {}
+            for section in record.section_ids:
+                new_section = section.copy({"domain_id": new_domain.id})
+                section_mapping[section.id] = new_section.id
+
+                for question in section.question_ids:
+                    question.copy({"section_id": new_section.id})
+
+            # Add targets to relationship table doesn't need to duplicate it
+            for target in record.target_ids:
+                new_domain.write({"target_rel_ids": [Command.link(target.id)]})
+
+            return {
+                "type": "ir.actions.client",
+                "tag": "display_notification",
+                "params": {
+                    "title": "Success",
+                    "message": f"Domain '{new_domain.name}' duplicated successfully!",
+                    "sticky": False,
+                    "type": "success",
+                },
+            }
diff --git a/audit/models/audit_inspector.py b/audit/models/audit_inspector.py
new file mode 100644
index 00000000000..3276a2fc166
--- /dev/null
+++ b/audit/models/audit_inspector.py
@@ -0,0 +1,107 @@
+"""Classes and backend functionality for Audit module"""
+
+import logging
+
+from odoo import api, fields, models
+
+_logger = logging.getLogger(__name__)
+
+
+class Inspector(models.Model):
+    """Inspector model: links partners and users for audit access."""
+
+    _name = "audit.inspector"
+    _description = "Audit Inspector"
+
+    res_user_id = fields.Many2one(
+        comodel_name="res.users",
+        string="Linked User",
+        help="Odoo user for this inspector (dashboards and access control).",
+        index=True,
+        ondelete="set null",
+    )
+    partner_id = fields.Many2one(
+        comodel_name="res.partner",
+        required=False,
+        ondelete="cascade",
+        string="Linked Partner",
+    )
+    name = fields.Char(
+        string="Inspector Name", required=True, help="Name of the audit inspector"
+    )
+    snapshot_ids = fields.One2many(
+        comodel_name="audit.snapshot", inverse_name="inspector_id", string="Snapshots"
+    )
+    team_ids = fields.Many2many(
+        comodel_name="audit.team",
+        string="Teams",
+    )
+
+    # Optional: make the email visible directly on Inspector,
+    # but keep it *related* to the partner record
+    inspector_email = fields.Char(
+        related="partner_id.email", store=True, readonly=False
+    )
+
+    # 'Name' already exists on res.partner, but we still want
+    # a full-name field, so we compute it from the partner value
+    full_name = fields.Char(compute="_compute_full_name", store=True)
+    forename = fields.Char()
+    surname = fields.Char()
+    active = fields.Boolean(default=True)
+
+    @api.depends("partner_id", "partner_id.name", "name")
+    def _split_name(self):
+        for rec in self:
+            if rec.partner_id and rec.partner_id.name:
+                parts = rec.partner_id.name.split(" ", 1)
+                rec.forename = parts[0]
+                rec.surname = parts[1] if len(parts) > 1 else ""
+
+            elif rec.name:
+                parts = rec.name.split(" ", 1)
+                rec.forename = parts[0]
+                rec.surname = parts[1] if len(parts) > 1 else ""
+
+            else:
+                rec.forename = ""
+                rec.surname = ""
+
+    @api.depends("partner_id", "partner_id.name", "forename", "surname")
+    def _compute_full_name(self):
+        """Optional helper if you still want a display name field."""
+
+        for rec in self:
+            if rec.partner_id and rec.partner_id.name:
+                rec.full_name = rec.partner_id.name
+
+            elif rec.forename or rec.surname:
+                rec.full_name = f"{rec.forename or ''} {rec.surname or ''}".strip()
+
+            else:
+                rec.full_name = rec.name or "Unnamed Inspector"
+
+    @api.model_create_multi
+    def create(self, vals_list):
+        """Ensure partner has required fields for delegation inheritance"""
+        for vals in vals_list:
+            # If no partner_id provided, we need to ensure the partner gets a name
+            if not vals.get("partner_id"):
+                # Build a name from available fields
+                name_parts = []
+                if vals.get("forename"):
+                    name_parts.append(vals["forename"])
+                if vals.get("surname"):
+                    name_parts.append(vals["surname"])
+
+                if name_parts:
+                    # Use the constructed name
+                    vals["name"] = " ".join(name_parts)
+                elif vals.get("inspector_email"):
+                    # Use email as fallback name
+                    vals["name"] = vals["inspector_email"]
+                elif not vals.get("name"):
+                    # Last resort - use a generic name
+                    vals["name"] = "Inspector"
+
+        return super().create(vals_list)
diff --git a/audit/models/audit_question.py b/audit/models/audit_question.py
new file mode 100644
index 00000000000..f8bd3fa510c
--- /dev/null
+++ b/audit/models/audit_question.py
@@ -0,0 +1,36 @@
+"""Classes and backend functionality for Audit module"""
+
+import logging
+
+from odoo import api, fields, models
+
+_logger = logging.getLogger(__name__)
+
+
+class Question(models.Model):
+    """
+    Question: each section has one or more questions; each domain has sections.
+    """
+
+    _name = "audit.question"
+    _description = "Questions for the form"
+
+    BOOLEAN = "boolean"
+    INTEGER = "integer"
+    FLOAT = "float"
+
+    QUESTION_OPTIONS = [
+        (BOOLEAN, "True / False"),
+        (INTEGER, "Star Rating"),
+        (FLOAT, "Percentage"),
+    ]
+
+    prompt = fields.Text()
+    answer_type = fields.Selection(selection=QUESTION_OPTIONS, required=True)
+    name = fields.Char(compute="_compute_name", store=True)
+    section_id = fields.Many2one(comodel_name="audit.section", required=True)
+
+    @api.depends("prompt")
+    def _compute_name(self):
+        for record in self:
+            record.name = record.prompt
diff --git a/audit/models/audit_section.py b/audit/models/audit_section.py
new file mode 100644
index 00000000000..cacd3eaba05
--- /dev/null
+++ b/audit/models/audit_section.py
@@ -0,0 +1,22 @@
+"""Classes and backend functionality for Audit module"""
+
+import logging
+
+from odoo import fields, models
+
+_logger = logging.getLogger(__name__)
+
+
+class Section(models.Model):
+    """Section model: an audit has many sections."""
+
+    _name = "audit.section"
+    _description = "To group questions"
+
+    name = fields.Text()
+    question_ids = fields.One2many(
+        comodel_name="audit.question", inverse_name="section_id", string="Questions"
+    )
+    domain_id = fields.Many2one(
+        comodel_name="audit.domain", string="Domain Name", required=True
+    )
diff --git a/audit/models/audit_snapshot.py b/audit/models/audit_snapshot.py
new file mode 100644
index 00000000000..623a65dcddf
--- /dev/null
+++ b/audit/models/audit_snapshot.py
@@ -0,0 +1,622 @@
+"""Classes and backend functionality for Audit module"""
+
+import json
+import logging
+from datetime import datetime
+from math import ceil
+
+import pytz
+
+from odoo import api, fields, models
+from odoo.exceptions import UserError
+
+_logger = logging.getLogger(__name__)
+
+
+# Copy the snapshot IDs across
+# UPDATE audit_snapshot_question
+# SET snapshot_id = audit_snapshot.id
+# FROM audit_snapshot
+# JOIN audit_snapshot_section ON audit_snapshot.id = audit_snapshot_section.snapshot_id
+# WHERE audit_snapshot_question.snapshot_section_id = audit_snapshot_section.id
+
+
+# Need start and end date times for the day in NZ
+# This date_str will be in yyyy-mm-dd format
+def convert_nz_to_utc(date_str):
+    """
+    Thank you chatgpt
+    """
+    time_format = "%Y-%m-%d %H:%M:%S.%f"
+
+    # Define the time zones
+    nz_tz = pytz.timezone("Pacific/Auckland")
+    utc_tz = pytz.utc
+
+    # Parse the input date string as yyyy-mm-dd
+    nz_start_time = datetime.strptime(date_str + " 00:00:00.999", time_format)
+    nz_end_time = datetime.strptime(date_str + " 23:59:59.999", time_format)
+
+    # Localize the datetime to New Zealand time zone (to consider daylight saving)
+    nz_start_time = nz_tz.localize(nz_start_time)
+    nz_end_time = nz_tz.localize(nz_end_time)
+
+    # Convert to UTC
+    utc_start_time = nz_start_time.astimezone(utc_tz)
+    utc_end_time = nz_end_time.astimezone(utc_tz)
+
+    # Return the UTC time in the same yyyy-mm-dd format
+    return {
+        "utc_start_time": utc_start_time.strftime(time_format),
+        "utc_end_time": utc_end_time.strftime(time_format),
+    }
+
+
+class SnapshotSection(models.Model):
+    """Snapshot section: a copy of each section when an audit snapshot is created."""
+
+    _name = "audit.snapshot_section"
+    _description = "We copy the section at the time the audit snapshot is created"
+
+    original_section_id = fields.Many2one(comodel_name="audit.section")
+    name = fields.Text()
+    snapshot_question_ids = fields.One2many(
+        comodel_name="audit.snapshot_question",
+        inverse_name="snapshot_section_id",
+        string="Questions",
+    )
+    domain_id = fields.Many2one(
+        comodel_name="audit.domain", string="Domain", required=True
+    )
+    snapshot_id = fields.Many2one(
+        comodel_name="audit.snapshot", string="Audit Snapshot"
+    )
+
+    # Section scores roll up to overall and per-section scores.
+    maximum_section_score = fields.Float(
+        compute="_compute_maximum_section_score", store=True
+    )
+
+    @api.depends("snapshot_question_ids")
+    def _compute_maximum_section_score(self):
+        for record in self:
+            record.maximum_section_score = 0.0
+            for _question in record.snapshot_question_ids:
+                record.maximum_section_score += 1
+
+    actual_section_score = fields.Float(
+        compute="_compute_actual_section_score", store=True
+    )
+
+    @api.depends("snapshot_question_ids", "snapshot_question_ids.value")
+    def _compute_actual_section_score(self):
+        for record in self:
+            record.actual_section_score = 0.0
+            for question in record.snapshot_question_ids:
+                record.actual_section_score += question.value
+
+    percentage_section_score = fields.Float(
+        compute="_compute_percentage_section_score", store=True
+    )
+
+    @api.depends("actual_section_score", "maximum_section_score")
+    def _compute_percentage_section_score(self):
+        for record in self:
+            if record.maximum_section_score == 0:
+                record.percentage_section_score = 0
+            else:
+                record.percentage_section_score = round(
+                    (record.actual_section_score / record.maximum_section_score), 2
+                )
+
+
+class SnapshotQuestion(models.Model):
+    """A snapshot of each question on the audit (one per Question on the template)."""
+
+    _name = "audit.snapshot_question"
+    _description = "Copy of the question"
+
+    YES = "1"
+    NO = "0"
+
+    ANSWER_SELECTION = [(YES, "Yes"), (NO, "No")]
+
+    ONE_STAR = "1"
+    TWO_STAR = "2"
+    THREE_STAR = "3"
+    FOUR_STAR = "4"
+
+    STAR_SELECTION = [
+        (ONE_STAR, "*"),
+        (TWO_STAR, "* *"),
+        (THREE_STAR, "* * *"),
+        (FOUR_STAR, "* * * *"),
+    ]
+
+    snapshot_id = fields.Many2one(comodel_name="audit.snapshot")
+    snapshot_section_id = fields.Many2one(
+        comodel_name="audit.snapshot_section", string="Section", required=True
+    )
+    original_question_id = fields.Many2one(comodel_name="audit.question")
+    prompt = fields.Text()
+    answer_type = fields.Char(required=True)
+
+    answer_yn = fields.Selection(selection=ANSWER_SELECTION)
+    answer_star = fields.Selection(selection=STAR_SELECTION)
+    answer_perc = fields.Float()  # min=0, max=100
+    # All questions are by default applicable, hence default=True
+    applicable = fields.Boolean(string="applicable", default=True)
+    comment = fields.Text()
+    image = fields.Image(string="image")
+    value = fields.Float(compute="_compute_value")
+
+    @api.depends("answer_yn", "answer_star", "answer_perc")
+    def _compute_value(recordset):
+        for record in recordset:
+            record.value = (
+                float(record.answer_yn)
+                + (float(record.answer_star) / 4)
+                + (record.answer_perc / 100)
+            )
+
+    @api.model
+    def toggle_not_applicable(self, *args, **kwargs):
+        """
+        Toggle the applicable field for the question.
+        Checks to see if snapshot is locked or not.
+        """
+        snapshot_question = self.env["audit.snapshot_question"].browse(args[0])
+        # if not snapshot_question.snapshot_id.locked: # this requirement was removed
+        snapshot_question.applicable = not snapshot_question.applicable
+        return {"id": snapshot_question.id, "applicable": snapshot_question.applicable}
+
+
+class Snapshot(models.Model):
+    """One record per completed audit (a snapshot of that run)."""
+
+    _name = "audit.snapshot"
+    _description = "Performing an audit creates a 'snapshot' of the item being audited."
+    _order = "date_conducted desc"
+
+    domain_id = fields.Many2one(comodel_name="audit.domain", string="Domain")
+    target_id = fields.Many2one(
+        comodel_name="audit.target", string="Target", required=True
+    )
+    date_conducted = fields.Datetime(default=datetime.today())
+    inspector_id = fields.Many2one(
+        comodel_name="audit.inspector", string="Inspector / Manager", required=True
+    )
+    notes = fields.Text()
+    snapshot_section_ids = fields.One2many(
+        comodel_name="audit.snapshot_section",
+        inverse_name="snapshot_id",
+        string="Sections",
+        required=True,
+    )
+
+    locked = fields.Boolean(string="locked", default=False)
+    name = fields.Text(compute="_compute_name")
+    maximum_score = fields.Float(compute="_compute_maximum_score")
+    actual_score = fields.Float(compute="_compute_actual_score")
+    # Per-section overall score, capped in logic so it does not exceed 100%.
+    percentage_score = fields.Float(compute="_compute_percentage_score", store=True)
+    # Count of snapshot questions on this snapshot that have a comment.
+    questions_with_comments = fields.Integer(compute="_compute_questions_with_comments")
+    # Active records are not archived.
+    active = fields.Boolean(default=True)
+
+    search_text = fields.Char(compute="_compute_search_text", store=True)
+    team_id = fields.Many2one(
+        comodel_name="audit.team", string="Team", ondelete="restrict", required=False
+    )
+
+    def get_snapshot_questions(self):
+        """Get the questions for a particular snapshot."""
+        snapshot = self
+        if not snapshot:
+            return {}
+
+        snapshot.ensure_one()
+        snapshot_questions = self.env["audit.snapshot_question"].search_read(
+            [("snapshot_section_id", "in", snapshot.snapshot_section_ids.ids)]
+        )
+        _sections_and_questions = {}
+        for snapshot_question in snapshot_questions:
+            if (
+                snapshot_question["snapshot_section_id"][1]
+                not in _sections_and_questions.keys()  # pylint: disable=consider-iterating-dictionary
+            ):
+                _sections_and_questions[
+                    snapshot_question["snapshot_section_id"][1]
+                ] = []
+
+        for snapshot_question in snapshot_questions:
+            _sections_and_questions.get(
+                snapshot_question["snapshot_section_id"][1], None
+            ).append(snapshot_question)
+
+        return {
+            "sections": [section.name for section in self.snapshot_section_ids],
+            "questions": _sections_and_questions,
+            "all_locked": self.locked,
+        }
+
+    @api.depends("domain_id", "target_id")
+    def _compute_search_text(self):
+        r"""
+        Search text compute: do not remove str() conversions.
+
+        This runs during new snapshot creation; removing str() breaks snapshot creation
+        in odoo-test and odoo-prod (not reproduced locally).
+        """
+        for record in self:
+            try:
+                record.search_text = ""
+
+                if record.domain_id:
+                    domain_name = record.domain_id.name
+                    if isinstance(domain_name, bool):
+                        domain_name = str(domain_name)
+                    record.search_text += str(domain_name)
+
+                if record.target_id:
+                    target_name = record.target_id.name
+                    if isinstance(target_name, bool):
+                        target_name = str(target_name)
+                    record.search_text += str(target_name)
+
+                if record.inspector_id:
+                    inspector_name = record.inspector_id.name
+                    if isinstance(inspector_name, bool):
+                        inspector_name = str(inspector_name)
+                    record.search_text += str(inspector_name)
+
+            except Exception as e:
+                _logger.error(
+                    "Snapshot::_compute_search_text: error for record %s: %s",
+                    record.id,
+                    str(e),
+                )
+                raise UserError(
+                    self.env._(
+                        "Failed to compute search text for snapshot %(id)s: %(err)s",
+                        id=record.id,
+                        err=str(e),
+                    )
+                ) from e
+
+    # Create snapshot sections and questions from the domain's template.
+    @api.model
+    def create(self, vals):
+        """Overriding the create function."""
+        if isinstance(vals, list):
+            # List create: use first item only (expected for this use case)
+            vals = vals[0] if vals else {}
+
+        # We can supply existing links
+        domain_id = vals.get("domain_id", None)
+        target_id = vals.get("target_id", None)
+        inspector_id = vals.get("inspector_id", None)
+        # Or we can create some
+        new_target_name = vals.get("new_target_name", None)
+        new_inspector_name = vals.get("new_inspector_name", None)
+
+        if domain_id is None:
+            raise UserError(self.env._("Must supply domain"))
+        if target_id is None and new_target_name is None:
+            raise UserError(self.env._("Must supply target or target name"))
+        if target_id is None and new_target_name is not None:
+            target = self.env["audit.target"].create(
+                {
+                    "name": new_target_name,
+                    "domain_rel_ids": [domain_id],
+                }
+            )
+            target_id = target.id
+        if inspector_id is None and new_inspector_name is None:
+            raise UserError(self.env._("Must supply inspector or inspector name"))
+        if inspector_id is None and new_inspector_name is not None:
+            inspector = self.env["audit.inspector"].create(
+                {
+                    "forename": new_inspector_name["forename"],
+                    "surname": new_inspector_name["surname"],
+                }
+            )
+            inspector_id = inspector.id
+
+        # Create snapshot, then link snapshot sections and questions.
+        # team_id: from vals, else first available team
+        team_id = vals.get("team_id")
+        if not team_id:
+            team = self.env["audit.team"].search([], limit=1)
+            team_id = team.id if team else None
+
+        new_snapshot = super().create(
+            {
+                "domain_id": domain_id,
+                "target_id": target_id,
+                "inspector_id": inspector_id,
+                "team_id": team_id,
+            }
+        )
+
+        # Now create snapshot_sections for each section linked to the domain id.
+        current_sections = self.env["audit.section"].search(
+            domain=[("domain_id", "=", domain_id)]
+        )
+        for section in current_sections:
+            snapshot_section = self.env["audit.snapshot_section"].create(
+                {
+                    "original_section_id": section.id,
+                    "name": section.name,
+                    "domain_id": domain_id,
+                    "snapshot_id": new_snapshot.id,
+                }
+            )
+            current_questions = self.env["audit.question"].search(
+                domain=[("section_id", "=", section.id)]
+            )
+
+            for question in current_questions:
+                self.env["audit.snapshot_question"].create(
+                    {
+                        "original_question_id": question.id,
+                        "snapshot_id": new_snapshot.id,
+                        "prompt": question.prompt,
+                        "snapshot_section_id": snapshot_section.id,
+                        "answer_type": question.answer_type,
+                    }
+                )
+
+        # pylint: disable=protected-access
+        # Sections and questions are created; compute max score (not from listeners)
+        new_snapshot._compute_maximum_score()
+        _logger.info(f"Snapshot::create > After _compute_maximum_score {new_snapshot}")
+        return new_snapshot
+
+    @api.depends("target_id", "target_id.name", "date_conducted")
+    def _compute_name(self):
+        for record in self:
+            if record.target_id:
+                record.name = "{} [{}]".format(
+                    record.target_id.name, record.date_conducted.strftime("%y-%m-%d")
+                )
+            else:
+                record.name = "Unnamed Snapshot"
+
+    @api.depends(
+        "snapshot_section_ids",
+        "snapshot_section_ids.snapshot_question_ids",
+        "snapshot_section_ids.snapshot_question_ids.applicable",
+    )
+    def _compute_maximum_score(snapshots):  # pylint disable=no-self-use
+        r"""
+        Avoid Odoo re-evaluating on all records: loop snapshots explicitly to prevent
+        Singleton errors when computing `maximum_score`.
+        """
+        for snapshot in snapshots:
+            snapshot.maximum_score = 0
+            for section in snapshot.snapshot_section_ids:
+                for question in section.snapshot_question_ids:
+                    if question.applicable:
+                        snapshot.maximum_score += 1
+
+    @api.depends(
+        "snapshot_section_ids",
+        "snapshot_section_ids.snapshot_question_ids",
+        "snapshot_section_ids.snapshot_question_ids.value",
+    )
+    def _compute_actual_score(snapshots):  # pylint disable=no-self-use
+        """
+        Add up only correct answers.
+        """
+        for snapshot in snapshots:
+            snapshot.actual_score = 0
+            for section in snapshot.snapshot_section_ids:
+                for question in section.snapshot_question_ids:
+                    if question.applicable:
+                        snapshot.actual_score += question.value
+
+    @api.depends("actual_score", "maximum_score")
+    def _compute_percentage_score(snapshots):
+        for snapshot in snapshots:
+            if snapshot.maximum_score == 0:
+                snapshot.percentage_score = 0
+            else:
+                # Shown in UI via a widget that maps decimal to float
+                snapshot.percentage_score = round(
+                    (snapshot.actual_score / snapshot.maximum_score), 2
+                )
+
+    def snapshot_percentage_score(self, snapshots: list):
+        """
+        Recompute actual, max, and percentage score for the given snapshot dicts.
+        Called from the frontend to refresh only the rows in view.
+        """
+        for snapshot in snapshots:
+            # Find the snapshot object
+            snapshot: object = self.env["audit.snapshot"].search(
+                [("id", "=", snapshot.get("id"))]
+            )
+            # Recompute scores first to avoid division by zero in percentage
+            # pylint: disable=protected-access
+            snapshot._compute_actual_score()
+            snapshot._compute_maximum_score()
+            snapshot._compute_percentage_score()
+            # pylint: enable=protected-access
+
+    @api.depends("snapshot_section_ids")
+    def _compute_questions_with_comments(snapshots):  # pylint disable=no-self-use
+        """If locked, count how many questions have a non-empty comment."""
+        for snapshot in snapshots:
+            snapshot.questions_with_comments = 0
+
+            if snapshot.read()[0]["locked"]:
+                snapshot_questions = snapshot.env["audit.snapshot_question"].search(
+                    [
+                        (
+                            "snapshot_section_id",
+                            "in",
+                            snapshot.read()[0]["snapshot_section_ids"],
+                        )
+                    ]
+                )
+                for snapshot_question in snapshot_questions:
+                    if snapshot_question.read()[0]["comment"]:
+                        snapshot.questions_with_comments += 1
+
+    # JSON search API for the dashboard: flexible filters, always paginated.
+    PAGE_SIZE = 15
+    PASS_THRESHOLD = 0.85
+
+    @api.model
+    def custom_search(self, search_string):
+        """
+        This helps search for audits
+        """
+        _logger.info(search_string)
+        search_object = json.loads(search_string)
+        search_query = [("active", "=", True)]
+        # Search name
+        if search_object.get("searchText"):
+            search_query.append(
+                (
+                    "search_text",
+                    "ilike",
+                    "%" + str(search_object.get("searchText")) + "%",
+                )
+            )
+        # Search status
+        if search_object.get("searchStatus"):
+            if str(search_object.get("searchStatus")) == "PASS":
+                search_query.append(("percentage_score", ">=", self.PASS_THRESHOLD))
+            elif str(search_object.get("searchStatus")) == "FAIL":
+                search_query.append(("percentage_score", "<", self.PASS_THRESHOLD))
+        if search_object.get("searchDate"):
+            # NZ local day [00:00, 24:00) to UTC (Pacific/Auckland).
+            utc_dates = convert_nz_to_utc(search_object.get("searchDate"))
+            search_query.append(("date_conducted", ">=", utc_dates["utc_start_time"]))
+            search_query.append(("date_conducted", "<=", utc_dates["utc_end_time"]))
+
+        # We need to make these conditions overlapping, so all must be met to filter.
+        for _i in range(0, len(search_query) - 1):
+            search_query.insert(0, "&")
+
+        # Get count (to compute page number)
+        snapshot_count = self.env["audit.snapshot"].search_count(search_query)
+        page_count = ceil(snapshot_count / self.PAGE_SIZE)
+        # If page number submitted is too high, fix that
+        page_number = search_object.get("searchPage")
+        if page_number > page_count > 0:
+            page_number = page_count
+
+        # Get data
+        logged_in_user_snapshosts, logged_in_user_snapshosts_count = (
+            self.snapshots_per_user(search_query=search_query, page_number=page_number)
+        )
+
+        # Update the snapshots in question before returning them
+        self.snapshot_percentage_score(logged_in_user_snapshosts)
+
+        return {
+            "snapshots": logged_in_user_snapshosts,
+            "numberOfPages": ceil(logged_in_user_snapshosts_count / self.PAGE_SIZE),
+            "newPageNumber": page_number,
+        }
+
+    # pylint: disable=too-many-return-statements
+    def snapshots_per_user(
+        self, search_query: list, page_number: int
+    ) -> tuple[list, int]:
+        """
+        Visibility rules for snapshot search:
+        1) Admin: all active snapshots
+        2) Team leader: own team's inspectors and leaders
+        3) Other inspector: own snapshots
+        4) No inspector profile: none
+        """
+        logged_in_user = self.env.user
+        admin_user = logged_in_user.has_group(
+            "base.group_system"
+        )  # Users/Administration/Settings
+        # If the user is an admin user then they should see all snapshots
+        offset = ((page_number - 1) * self.PAGE_SIZE) if page_number > 0 else 0
+        if admin_user:
+            return self.env["audit.snapshot"].search_read(
+                search_query,
+                limit=self.PAGE_SIZE,
+                offset=offset,
+                order="date_conducted desc",
+            ), self.env["audit.snapshot"].search_count([("active", "=", True)])
+
+        # Find inspector row for this user (res.user or partner).
+        inspector = self.env["audit.inspector"].search(
+            [
+                "|",
+                ("res_user_id", "=", logged_in_user.id),
+                ("partner_id", "=", logged_in_user.partner_id.id),
+            ],
+            limit=1,
+        )
+
+        # No inspector?  no snapshots
+        if not inspector:
+            return [], 0
+
+        team = inspector and self.env["audit.team"].search(
+            [
+                "|",
+                ("team_member_ids", "in", inspector.id),
+                ("team_leader_ids", "in", inspector.id),
+            ]
+        )
+        team_leader = team and team.team_leader_ids
+        team_members = team and team.team_member_ids
+
+        if inspector and team:
+            if inspector.id in team_leader.ids:  # Logged-in user is a team leader
+                return self.env["audit.snapshot"].search_read(
+                    [
+                        (
+                            "inspector_id",
+                            "in",
+                            list(set(team_members.ids + team_leader.ids)),
+                        )
+                    ],
+                    limit=self.PAGE_SIZE,
+                    offset=offset,
+                    order="date_conducted desc",
+                ), self.env["audit.snapshot"].search_count(
+                    [
+                        ("active", "=", True),
+                        (
+                            "inspector_id",
+                            "in",
+                            set(team_members.ids + team_leader.ids),
+                        ),
+                    ]
+                )
+
+            if inspector.id not in team_leader.ids:  # Logged-in user not a team leader
+                return self.env["audit.snapshot"].search_read(
+                    [("inspector_id", "=", inspector.id)],
+                    limit=self.PAGE_SIZE,
+                    offset=offset,
+                    order="date_conducted desc",
+                ), self.env["audit.snapshot"].search_count(
+                    [("active", "=", True), ("inspector_id", "=", inspector.id)]
+                )
+
+            return [], 0
+
+        if inspector and not team:  # Inspector not part of a team
+            return self.env["audit.snapshot"].search_read(
+                [("inspector_id", "=", inspector.id)],
+                limit=self.PAGE_SIZE,
+                offset=offset,
+                order="date_conducted desc",
+            ), self.env["audit.snapshot"].search_count(
+                [("active", "=", True), ("inspector_id", "=", inspector.id)]
+            )
+
+        return [], 0
diff --git a/audit/models/audit_target.py b/audit/models/audit_target.py
new file mode 100644
index 00000000000..e84e47d44b1
--- /dev/null
+++ b/audit/models/audit_target.py
@@ -0,0 +1,192 @@
+"""Classes and backend functionality for Audit module"""
+
+import logging
+
+from odoo import api, fields, models
+from odoo.exceptions import ValidationError
+
+_logger = logging.getLogger(__name__)
+
+
+class DomainTargetRel(models.Model):
+    """M2M link between audit domains and targets (one target per domain row)."""
+
+    _name = "audit.domain_target_rel"
+    _description = "Audit Domain Target Relation"
+    _rec_name = "target_id"
+    _order = "id asc"
+
+    _unique_domain_target = models.Constraint(
+        "unique(domain_id, target_id)",
+        "This target is already linked to the domain.",
+    )
+
+    domain_id = fields.Many2one(
+        comodel_name="audit.domain",
+        string="Audit Domain",
+        required=True,
+        ondelete="cascade",
+    )
+    target_id = fields.Many2one(
+        comodel_name="audit.target",
+        string="Audit Target",
+        required=True,
+        ondelete="cascade",
+    )
+
+
+class Target(models.Model):
+    """
+    Target model: an audit can have one or more targets per domain.
+    A specific business subject within a domain that is being audited.
+    """
+
+    _name = "audit.target"
+    _description = "Audit Target"
+    _order = "name asc"
+
+    name = fields.Text()
+    domain_id = fields.Many2one(
+        comodel_name="audit.domain", string="Audit Domain", required=False
+    )
+
+    domain_rel_ids = fields.Many2many(
+        comodel_name="audit.domain",
+        relation="audit_domain_target_rel",
+        column1="target_id",
+        column2="domain_id",
+        string="Linked Audit Domains",
+    )
+
+    snapshot_ids = fields.One2many(
+        comodel_name="audit.snapshot",
+        inverse_name="target_id",
+        string="Audit Snapshots",
+    )
+
+    all_domain_rel_ids = fields.Many2many(
+        comodel_name="audit.domain",
+        compute="_compute_all_domain_ids",
+        inverse="_inverse_all_domain_ids",
+        string="All Domains",
+        store=False,  # Do not store, computed dynamically
+    )
+
+    @api.depends("domain_id", "domain_rel_ids")
+    def _compute_all_domain_ids(self):
+        """Compute a Many2many field combining Main Domain and Related Domains"""
+        for record in self:
+            domain_records = record.domain_rel_ids
+            if record.domain_id:
+                domain_records |= record.domain_id  # Add the primary domain
+
+            record.all_domain_rel_ids = domain_records  # Assign the merged domains
+
+    def _inverse_all_domain_ids(self):
+        """Ensure new domain added via UI are linked to Many2many (`domain_rel_ids`)"""
+        for record in self:
+            record.domain_rel_ids = record.all_domain_rel_ids
+
+    @api.model
+    def create(self, vals_list):
+        """Set ``domain_id`` if missing; reject duplicate target names."""
+        # Handle both single dict and list of dicts
+        if not isinstance(vals_list, list):
+            vals_list = [vals_list]
+
+        for vals in vals_list:
+            # Set domain_id from all_domain_rel_ids if missing
+            if not vals.get("domain_id") and vals.get("all_domain_rel_ids"):
+                domain_rel_ids = (
+                    vals["all_domain_rel_ids"][0][2]
+                    if isinstance(vals["all_domain_rel_ids"], list)
+                    else []
+                )
+                if domain_rel_ids:
+                    vals["domain_id"] = domain_rel_ids[0]
+
+            # Prevent duplicate targets with the same name in the same domain
+            existing_target = self.env["audit.target"].search(
+                [("name", "=", vals.get("name"))], limit=1
+            )
+
+            if existing_target:
+                raise ValidationError(
+                    self.env._(
+                        "A target with the name '%(name)s' already exists !",
+                        name=vals.get("name"),
+                    )
+                )
+
+        # Call parent create method with the processed vals_list
+        return super().create(vals_list)
+
+    def link_to_domain(self, domain_id, target_id):
+        """
+        Check if link exists already, if not link it
+        """
+        domain_links = self.env["audit.domain_target_rel"].search(
+            [("target_id", "=", target_id), ("domain_id", "=", domain_id)]
+        )
+        if bool(domain_links) is False:
+            self.env["audit.domain_target_rel"].create(
+                {
+                    "domain_id": domain_id,
+                    "target_id": target_id,
+                }
+            )
+
+    def merge(self):
+        """
+        This will find matching targets then overwrite their IDs in the snapshot table
+        """
+        if self.domain_id:
+            self.link_to_domain(self.domain_id.id, self.id)
+        matching_targets = self.env["audit.target"].search([("name", "=", self.name)])
+        for matching_target in matching_targets:
+            if matching_target.id != self.id:
+                # Move snapshots to original target
+                for snapshot in self.env["audit.snapshot"].search(
+                    [("target_id", "=", matching_target.id)]
+                ):
+                    snapshot.target_id = self.id
+                # Check for domains that need to be merged as well
+                if matching_target.domain_id:
+                    self.link_to_domain(matching_target.domain_id.id, self.id)
+                matching_target.unlink()
+        # Clear primary domain and M2M links, otherwise `write` below re-fills
+        # ``domain_id`` from ``all_domain_rel_ids`` when only ``domain_id`` is cleared.
+        self.write(
+            {
+                "domain_id": False,
+                "domain_rel_ids": [(5, 0, 0)],
+            }
+        )
+
+    def write(self, vals):
+        """Update domain from related fields and block duplicate target names."""
+        for record in self:
+            new_name = vals.get("name", record.name)
+            duplicate = self.env["audit.target"].search(
+                [
+                    ("name", "=", new_name),
+                    ("id", "!=", record.id),  # Exclude current record to allow updates
+                ],
+                limit=1,
+            )
+
+            if duplicate:
+                raise ValidationError(
+                    self.env._(
+                        "A target with the name '%(name)s' already exists !",
+                        name=new_name,
+                    )
+                )
+
+        # Ensure domain_id is assigned if missing
+        res = super().write(vals)
+        for record in self:
+            if not record.domain_id and record.all_domain_rel_ids:
+                record.domain_id = record.all_domain_rel_ids[0]
+
+        return res
diff --git a/audit/models/audit_team.py b/audit/models/audit_team.py
new file mode 100644
index 00000000000..eff3876829b
--- /dev/null
+++ b/audit/models/audit_team.py
@@ -0,0 +1,29 @@
+"""Audit team models for the audit app."""
+
+from odoo import fields, models
+
+
+class AuditTeam(models.Model):
+    """Represents a team of inspectors and leaders for audits."""
+
+    _name = "audit.team"
+    _description = "Audit Team"
+
+    _name_unique = models.Constraint("UNIQUE(name)", "Team name must be unique!")
+
+    name = fields.Char(required=True)
+    team_member_ids = fields.Many2many(
+        comodel_name="audit.inspector",
+        relation="audit_team_member_rel",
+        column1="team_id",
+        column2="user_id",
+        string="Team Members",
+    )
+    # Leaders can see everyone's snapshots in that team
+    team_leader_ids = fields.Many2many(
+        comodel_name="audit.inspector",
+        relation="audit_team_leader_rel",
+        column1="team_id",
+        column2="user_id",
+        string="Team Leaders",
+    )
diff --git a/audit/pyproject.toml b/audit/pyproject.toml
new file mode 100644
index 00000000000..4231d0cccb3
--- /dev/null
+++ b/audit/pyproject.toml
@@ -0,0 +1,3 @@
+[build-system]
+requires = ["whool"]
+build-backend = "whool.buildapi"
diff --git a/audit/security/ir.model.access.csv b/audit/security/ir.model.access.csv
new file mode 100644
index 00000000000..1688c2819d8
--- /dev/null
+++ b/audit/security/ir.model.access.csv
@@ -0,0 +1,13 @@
+id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
+access_audit_domain,audit.domain,model_audit_domain,audit.group_audit_permission,1,1,1,1
+access_audit_target,audit.target,model_audit_target,audit.group_audit_permission,1,1,1,1
+access_audit_inspector,audit.inspector,model_audit_inspector,audit.group_audit_permission,1,1,1,1
+access_audit_section,audit.section,model_audit_section,audit.group_audit_permission,1,1,1,1
+access_audit_question,audit.question,model_audit_question,audit.group_audit_permission,1,1,1,1
+access_audit_snapshot,audit.snapshot,model_audit_snapshot,audit.group_audit_permission,1,1,1,1
+access_audit_snapshot_section,audit.snapshot_section,model_audit_snapshot_section,audit.group_audit_permission,1,1,1,1
+access_audit_snapshot_question,audit.snapshot_question,model_audit_snapshot_question,audit.group_audit_permission,1,1,1,1
+access_audit_domain_target_rel,audit.domain_target_rel,model_audit_domain_target_rel,audit.group_audit_permission,1,1,1,1
+access_audit_menu_access_control,audit.menu.access.control,model_audit_menu_access_control,audit.group_audit_permission,1,1,1,1
+access_audit_team_user,audit.team user,model_audit_team,audit.group_audit_permission,1,1,1,1
+access_audit_team_admin,audit.team admin,model_audit_team,audit.group_audit_permission,1,1,1,1
diff --git a/audit/security/security.xml b/audit/security/security.xml
new file mode 100644
index 00000000000..ded916963e8
--- /dev/null
+++ b/audit/security/security.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<odoo>
+    <record model="ir.module.category" id="module_category_audit">
+        <field name="name">Audit</field>
+        <field name="sequence">230</field>
+    </record>
+
+    <record id="res_groups_privilege_audit" model="res.groups.privilege">
+        <field name="name">Audit</field>
+        <field name="category_id" ref="module_category_audit" />
+        <field name="sequence">1</field>
+    </record>
+
+    <record id="group_audit_permission" model="res.groups">
+        <field name="name">Audit Permission</field>
+        <field name="privilege_id" ref="res_groups_privilege_audit" />
+        <field name="implied_ids" eval="[Command.link(ref('base.group_user'))]" />
+    </record>
+</odoo>
diff --git a/audit/static/description/icon-512.png b/audit/static/description/icon-512.png
new file mode 100644
index 00000000000..2c799d6ec90
Binary files /dev/null and b/audit/static/description/icon-512.png differ
diff --git a/audit/static/description/icon.png b/audit/static/description/icon.png
new file mode 100644
index 00000000000..9bc8e2485af
Binary files /dev/null and b/audit/static/description/icon.png differ
diff --git a/audit/static/src/css/audit_styles.css b/audit/static/src/css/audit_styles.css
new file mode 100644
index 00000000000..3ffcb2e7fa4
--- /dev/null
+++ b/audit/static/src/css/audit_styles.css
@@ -0,0 +1,18 @@
+/* Pass/Fail styling for percentage scores */
+.pass-fail-score.text-success::before {
+    content: "PASS";
+    padding: 2px 6px;
+    border-radius: 3px;
+    font-size: 0.95rem;
+    margin-right: 6px;
+    font-weight: bold;
+}
+
+.pass-fail-score.text-danger::before {
+    content: "FAIL";
+    padding: 2px 6px;
+    border-radius: 3px;
+    font-size: 0.95rem;
+    margin-right: 6px;
+    font-weight: bold;
+}
diff --git a/audit/static/src/css/audit_team.css b/audit/static/src/css/audit_team.css
new file mode 100644
index 00000000000..9ae1b2afd61
--- /dev/null
+++ b/audit/static/src/css/audit_team.css
@@ -0,0 +1,11 @@
+/* Audit Team Name Styling - Targeted but reliable selector */
+.o_field_char.audit_team_name_field {
+    background-color: #d1ecf1 !important;
+    color: #0c5460 !important;
+    border: 3px solid #bee5eb !important;
+    border-radius: 10px !important;
+    max-width: fit-content !important;
+    padding: 8px 12px !important;
+    font-weight: 500 !important;
+    margin-bottom: 30px !important;
+}
diff --git a/audit/static/src/css/fontawesome.js b/audit/static/src/css/fontawesome.js
new file mode 100644
index 00000000000..4ba7e1ddeb0
--- /dev/null
+++ b/audit/static/src/css/fontawesome.js
@@ -0,0 +1,743 @@
+window.FontAwesomeKitConfig = {
+    id: 38106326,
+    version: "6.5.1",
+    token: "2263bf088c",
+    method: "css",
+    baseUrl: "https://ka-f.fontawesome.com",
+    license: "free",
+    asyncLoading: {enabled: false},
+    autoA11y: {enabled: true},
+    baseUrlKit: "https://kit.fontawesome.com",
+    detectConflictsUntil: null,
+    iconUploads: {},
+    minify: {enabled: true},
+    v4FontFaceShim: {enabled: true},
+    v4shim: {enabled: true},
+    v5FontFaceShim: {enabled: true},
+};
+!(function (t) {
+    "function" == typeof define && define.amd ? define("kit-loader", t) : t();
+})(function () {
+    "use strict";
+    function t(t, e) {
+        var n = Object.keys(t);
+        if (Object.getOwnPropertySymbols) {
+            var r = Object.getOwnPropertySymbols(t);
+            (e &&
+                (r = r.filter(function (e) {
+                    return Object.getOwnPropertyDescriptor(t, e).enumerable;
+                })),
+                n.push.apply(n, r));
+        }
+        return n;
+    }
+    function e(e) {
+        for (var n = 1; n < arguments.length; n++) {
+            var o = null != arguments[n] ? arguments[n] : {};
+            n % 2
+                ? t(Object(o), !0).forEach(function (t) {
+                      r(e, t, o[t]);
+                  })
+                : Object.getOwnPropertyDescriptors
+                  ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(o))
+                  : t(Object(o)).forEach(function (t) {
+                        Object.defineProperty(
+                            e,
+                            t,
+                            Object.getOwnPropertyDescriptor(o, t)
+                        );
+                    });
+        }
+        return e;
+    }
+    function n(t) {
+        return (n =
+            "function" == typeof Symbol && "symbol" == typeof Symbol.iterator
+                ? function (t) {
+                      return typeof t;
+                  }
+                : function (t) {
+                      return t &&
+                          "function" == typeof Symbol &&
+                          t.constructor === Symbol &&
+                          t !== Symbol.prototype
+                          ? "symbol"
+                          : typeof t;
+                  })(t);
+    }
+    function r(t, e, n) {
+        return (
+            (e = (function (t) {
+                var e = (function (t, e) {
+                    if ("object" != typeof t || null === t) return t;
+                    var n = t[Symbol.toPrimitive];
+                    if (void 0 !== n) {
+                        var r = n.call(t, e || "default");
+                        if ("object" != typeof r) return r;
+                        throw new TypeError(
+                            "@@toPrimitive must return a primitive value."
+                        );
+                    }
+                    return ("string" === e ? String : Number)(t);
+                })(t, "string");
+                return "symbol" == typeof e ? e : String(e);
+            })(e)) in t
+                ? Object.defineProperty(t, e, {
+                      value: n,
+                      enumerable: !0,
+                      configurable: !0,
+                      writable: !0,
+                  })
+                : (t[e] = n),
+            t
+        );
+    }
+    function o(t, e) {
+        return (
+            (function (t) {
+                if (Array.isArray(t)) return t;
+            })(t) ||
+            (function (t, e) {
+                var n =
+                    null == t
+                        ? null
+                        : ("undefined" != typeof Symbol && t[Symbol.iterator]) ||
+                          t["@@iterator"];
+                if (null != n) {
+                    var r,
+                        o,
+                        i,
+                        a,
+                        c = [],
+                        u = !0,
+                        f = !1;
+                    try {
+                        if (((i = (n = n.call(t)).next), 0 === e)) {
+                            if (Object(n) !== n) return;
+                            u = !1;
+                        } else
+                            for (
+                                ;
+                                !(u = (r = i.call(n)).done) &&
+                                (c.push(r.value), c.length !== e);
+                                u = !0
+                            );
+                    } catch (t) {
+                        ((f = !0), (o = t));
+                    } finally {
+                        try {
+                            if (
+                                !u &&
+                                null != n.return &&
+                                ((a = n.return()), Object(a) !== a)
+                            )
+                                return;
+                        } finally {
+                            if (f) throw o;
+                        }
+                    }
+                    return c;
+                }
+            })(t, e) ||
+            (function (t, e) {
+                if (!t) return;
+                if ("string" == typeof t) return i(t, e);
+                var n = Object.prototype.toString.call(t).slice(8, -1);
+                "Object" === n && t.constructor && (n = t.constructor.name);
+                if ("Map" === n || "Set" === n) return Array.from(t);
+                if (
+                    "Arguments" === n ||
+                    /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)
+                )
+                    return i(t, e);
+            })(t, e) ||
+            (function () {
+                throw new TypeError(
+                    "Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
+                );
+            })()
+        );
+    }
+    function i(t, e) {
+        (null == e || e > t.length) && (e = t.length);
+        for (var n = 0, r = new Array(e); n < e; n++) r[n] = t[n];
+        return r;
+    }
+    var a = "sharp",
+        c = ["classic", "duotone", "sharp"],
+        u = ["fak", "fa-kit", "fakd", "fa-kit-duotone"],
+        f = [
+            "fa",
+            "fas",
+            "fa-solid",
+            "far",
+            "fa-regular",
+            "fal",
+            "fa-light",
+            "fat",
+            "fa-thin",
+            "fad",
+            "fa-duotone",
+            "fab",
+            "fa-brands",
+            "fass",
+            "fasr",
+            "fasl",
+            "fast",
+        ];
+    function s(t, e) {
+        var n = (e && e.addOn) || "",
+            r = (e && e.baseFilename) || t.license + n,
+            o = e && e.minify ? ".min" : "",
+            i = (e && e.fileSuffix) || t.method,
+            a = (e && e.subdir) || t.method;
+        return (
+            t.baseUrl +
+            "/releases/" +
+            ("latest" === t.version ? "latest" : "v".concat(t.version)) +
+            "/" +
+            a +
+            "/" +
+            r +
+            o +
+            "." +
+            i
+        );
+    }
+    function d(t, e) {
+        var n = e || ["fa"],
+            r = "." + Array.prototype.join.call(n, ",."),
+            o = t.querySelectorAll(r);
+        Array.prototype.forEach.call(o, function (e) {
+            var n = e.getAttribute("title");
+            e.setAttribute("aria-hidden", "true");
+            var r =
+                !e.nextElementSibling ||
+                !e.nextElementSibling.classList.contains("sr-only");
+            if (n && r) {
+                var o = t.createElement("span");
+                ((o.innerHTML = n),
+                    o.classList.add("sr-only"),
+                    e.parentNode.insertBefore(o, e.nextSibling));
+            }
+        });
+    }
+    var l,
+        h = function () {},
+        m =
+            "undefined" != typeof global &&
+            void 0 !== global.process &&
+            "function" == typeof global.process.emit,
+        p = "undefined" == typeof setImmediate ? setTimeout : setImmediate,
+        v = [];
+    function b() {
+        for (var t = 0; t < v.length; t++) v[t][0](v[t][1]);
+        ((v = []), (l = !1));
+    }
+    function y(t, e) {
+        (v.push([t, e]), l || ((l = !0), p(b, 0)));
+    }
+    function g(t) {
+        var e = t.owner,
+            n = e._state,
+            r = e._data,
+            o = t[n],
+            i = t.then;
+        if ("function" == typeof o) {
+            n = "fulfilled";
+            try {
+                r = o(r);
+            } catch (t) {
+                O(i, t);
+            }
+        }
+        w(i, r) || ("fulfilled" === n && A(i, r), "rejected" === n && O(i, r));
+    }
+    function w(t, e) {
+        var r;
+        try {
+            if (t === e)
+                throw new TypeError(
+                    "A promises callback cannot return that same promise."
+                );
+            if (e && ("function" == typeof e || "object" === n(e))) {
+                var o = e.then;
+                if ("function" == typeof o)
+                    return (
+                        o.call(
+                            e,
+                            function (n) {
+                                r || ((r = !0), e === n ? S(t, n) : A(t, n));
+                            },
+                            function (e) {
+                                r || ((r = !0), O(t, e));
+                            }
+                        ),
+                        !0
+                    );
+            }
+        } catch (e) {
+            return (r || O(t, e), !0);
+        }
+        return !1;
+    }
+    function A(t, e) {
+        (t !== e && w(t, e)) || S(t, e);
+    }
+    function S(t, e) {
+        "pending" === t._state && ((t._state = "settled"), (t._data = e), y(E, t));
+    }
+    function O(t, e) {
+        "pending" === t._state && ((t._state = "settled"), (t._data = e), y(P, t));
+    }
+    function j(t) {
+        t._then = t._then.forEach(g);
+    }
+    function E(t) {
+        ((t._state = "fulfilled"), j(t));
+    }
+    function P(t) {
+        ((t._state = "rejected"),
+            j(t),
+            !t._handled && m && global.process.emit("unhandledRejection", t._data, t));
+    }
+    function _(t) {
+        global.process.emit("rejectionHandled", t);
+    }
+    function F(t) {
+        if ("function" != typeof t)
+            throw new TypeError("Promise resolver " + t + " is not a function");
+        if (this instanceof F == !1)
+            throw new TypeError(
+                "Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function."
+            );
+        ((this._then = []),
+            (function (t, e) {
+                function n(t) {
+                    O(e, t);
+                }
+                try {
+                    t(function (t) {
+                        A(e, t);
+                    }, n);
+                } catch (t) {
+                    n(t);
+                }
+            })(t, this));
+    }
+    ((F.prototype = {
+        constructor: F,
+        _state: "pending",
+        _then: null,
+        _data: void 0,
+        _handled: !1,
+        then: function (t, e) {
+            var n = {
+                owner: this,
+                then: new this.constructor(h),
+                fulfilled: t,
+                rejected: e,
+            };
+            return (
+                (!e && !t) ||
+                    this._handled ||
+                    ((this._handled = !0),
+                    "rejected" === this._state && m && y(_, this)),
+                "fulfilled" === this._state || "rejected" === this._state
+                    ? y(g, n)
+                    : this._then.push(n),
+                n.then
+            );
+        },
+        catch: function (t) {
+            return this.then(null, t);
+        },
+    }),
+        (F.all = function (t) {
+            if (!Array.isArray(t))
+                throw new TypeError("You must pass an array to Promise.all().");
+            return new F(function (e, n) {
+                var r = [],
+                    o = 0;
+                function i(t) {
+                    return (
+                        o++,
+                        function (n) {
+                            ((r[t] = n), --o || e(r));
+                        }
+                    );
+                }
+                for (var a, c = 0; c < t.length; c++)
+                    (a = t[c]) && "function" == typeof a.then
+                        ? a.then(i(c), n)
+                        : (r[c] = a);
+                o || e(r);
+            });
+        }),
+        (F.race = function (t) {
+            if (!Array.isArray(t))
+                throw new TypeError("You must pass an array to Promise.race().");
+            return new F(function (e, n) {
+                for (var r, o = 0; o < t.length; o++)
+                    (r = t[o]) && "function" == typeof r.then ? r.then(e, n) : e(r);
+            });
+        }),
+        (F.resolve = function (t) {
+            return t && "object" === n(t) && t.constructor === F
+                ? t
+                : new F(function (e) {
+                      e(t);
+                  });
+        }),
+        (F.reject = function (t) {
+            return new F(function (e, n) {
+                n(t);
+            });
+        }));
+    var C = "function" == typeof Promise ? Promise : F;
+    function I(t, e) {
+        var n = e.fetch,
+            r = e.XMLHttpRequest,
+            o = e.token,
+            i = t;
+        return (
+            o &&
+                !(function (t) {
+                    return t.indexOf("kit-upload.css") > -1;
+                })(t) &&
+                ("URLSearchParams" in window
+                    ? (i = new URL(t)).searchParams.set("token", o)
+                    : (i = i + "?token=" + encodeURIComponent(o))),
+            (i = i.toString()),
+            new C(function (t, e) {
+                if ("function" == typeof n)
+                    n(i, {mode: "cors", cache: "default"})
+                        .then(function (t) {
+                            if (t.ok) return t.text();
+                            throw new Error("");
+                        })
+                        .then(function (e) {
+                            t(e);
+                        })
+                        .catch(e);
+                else if ("function" == typeof r) {
+                    var o = new r();
+                    o.addEventListener("loadend", function () {
+                        this.responseText ? t(this.responseText) : e(new Error(""));
+                    });
+                    (["abort", "error", "timeout"].map(function (t) {
+                        o.addEventListener(t, function () {
+                            e(new Error(""));
+                        });
+                    }),
+                        o.open("GET", i),
+                        o.send());
+                } else {
+                    e(new Error(""));
+                }
+            })
+        );
+    }
+    function U(t, e, n) {
+        var r = t;
+        return (
+            [
+                [
+                    /(url\("?)\.\.\/\.\.\/\.\./g,
+                    function (t, n) {
+                        return "".concat(n).concat(e);
+                    },
+                ],
+                [
+                    /(url\("?)\.\.\/webfonts/g,
+                    function (t, r) {
+                        return ""
+                            .concat(r)
+                            .concat(e, "/releases/v")
+                            .concat(n, "/webfonts");
+                    },
+                ],
+                [
+                    /(url\("?)https:\/\/kit-free([^.])*\.fontawesome\.com/g,
+                    function (t, n) {
+                        return "".concat(n).concat(e);
+                    },
+                ],
+            ].forEach(function (t) {
+                var e = o(t, 2),
+                    n = e[0],
+                    i = e[1];
+                r = r.replace(n, i);
+            }),
+            r
+        );
+    }
+    function k(t, n) {
+        var r =
+                arguments.length > 2 && void 0 !== arguments[2]
+                    ? arguments[2]
+                    : function () {},
+            o = n.document || o,
+            i = d.bind(
+                d,
+                o,
+                [].concat(
+                    f,
+                    u,
+                    c.map(function (t) {
+                        return "fa-".concat(t);
+                    })
+                )
+            );
+        t.autoA11y.enabled && r(i);
+        var a = t.subsetPath && t.baseUrl + "/" + t.subsetPath,
+            l = [{id: "fa-main", addOn: void 0, url: a}];
+        if (
+            (t.v4shim &&
+                t.v4shim.enabled &&
+                l.push({id: "fa-v4-shims", addOn: "-v4-shims"}),
+            t.v5FontFaceShim &&
+                t.v5FontFaceShim.enabled &&
+                l.push({id: "fa-v5-font-face", addOn: "-v5-font-face"}),
+            t.v4FontFaceShim &&
+                t.v4FontFaceShim.enabled &&
+                l.push({id: "fa-v4-font-face", addOn: "-v4-font-face"}),
+            !a && t.customIconsCssPath)
+        ) {
+            var h =
+                    t.customIconsCssPath.indexOf("kit-upload.css") > -1
+                        ? t.baseUrlKit
+                        : t.baseUrl,
+                m = h + "/" + t.customIconsCssPath;
+            l.push({id: "fa-kit-upload", url: m});
+        }
+        var p = l.map(function (r) {
+            return new C(function (o, i) {
+                var a = r.url || s(t, {addOn: r.addOn, minify: t.minify.enabled}),
+                    c = {id: r.id},
+                    u = t.subset
+                        ? c
+                        : e(
+                              e(e({}, n), c),
+                              {},
+                              {
+                                  baseUrl: t.baseUrl,
+                                  version: t.version,
+                                  id: r.id,
+                                  contentFilter: function (t, e) {
+                                      return U(t, e.baseUrl, e.version);
+                                  },
+                              }
+                          );
+                I(a, n)
+                    .then(function (t) {
+                        o(T(t, u));
+                    })
+                    .catch(i);
+            });
+        });
+        return C.all(p);
+    }
+    function T(t, e) {
+        var n =
+                e.contentFilter ||
+                function (t, e) {
+                    return t;
+                },
+            r = document.createElement("style"),
+            o = document.createTextNode(n(t, e));
+        return (
+            r.appendChild(o),
+            (r.media = "all"),
+            e.id && r.setAttribute("id", e.id),
+            e &&
+                e.detectingConflicts &&
+                e.detectionIgnoreAttr &&
+                r.setAttributeNode(document.createAttribute(e.detectionIgnoreAttr)),
+            r
+        );
+    }
+    function L(t, n) {
+        ((n.autoA11y = t.autoA11y.enabled),
+            "pro" === t.license &&
+                ((n.autoFetchSvg = !0),
+                (n.fetchSvgFrom =
+                    t.baseUrl +
+                    "/releases/" +
+                    ("latest" === t.version ? "latest" : "v".concat(t.version)) +
+                    "/svgs"),
+                (n.fetchUploadedSvgFrom = t.uploadsUrl)));
+        var r = [];
+        return (
+            t.v4shim.enabled &&
+                r.push(
+                    new C(function (r, o) {
+                        I(s(t, {addOn: "-v4-shims", minify: t.minify.enabled}), n)
+                            .then(function (t) {
+                                r(x(t, e(e({}, n), {}, {id: "fa-v4-shims"})));
+                            })
+                            .catch(o);
+                    })
+                ),
+            r.push(
+                new C(function (r, o) {
+                    I(
+                        (t.subsetPath && t.baseUrl + "/" + t.subsetPath) ||
+                            s(t, {minify: t.minify.enabled}),
+                        n
+                    )
+                        .then(function (t) {
+                            var o = x(t, e(e({}, n), {}, {id: "fa-main"}));
+                            r(
+                                (function (t, e) {
+                                    var n =
+                                            e && void 0 !== e.autoFetchSvg
+                                                ? e.autoFetchSvg
+                                                : void 0,
+                                        r =
+                                            e && void 0 !== e.autoA11y
+                                                ? e.autoA11y
+                                                : void 0;
+                                    void 0 !== r &&
+                                        t.setAttribute(
+                                            "data-auto-a11y",
+                                            r ? "true" : "false"
+                                        );
+                                    n &&
+                                        (t.setAttributeNode(
+                                            document.createAttribute(
+                                                "data-auto-fetch-svg"
+                                            )
+                                        ),
+                                        t.setAttribute(
+                                            "data-fetch-svg-from",
+                                            e.fetchSvgFrom
+                                        ),
+                                        t.setAttribute(
+                                            "data-fetch-uploaded-svg-from",
+                                            e.fetchUploadedSvgFrom
+                                        ));
+                                    return t;
+                                })(o, n)
+                            );
+                        })
+                        .catch(o);
+                })
+            ),
+            C.all(r)
+        );
+    }
+    function x(t, e) {
+        var n = document.createElement("SCRIPT"),
+            r = document.createTextNode(t);
+        return (
+            n.appendChild(r),
+            (n.referrerPolicy = "strict-origin"),
+            e.id && n.setAttribute("id", e.id),
+            e &&
+                e.detectingConflicts &&
+                e.detectionIgnoreAttr &&
+                n.setAttributeNode(document.createAttribute(e.detectionIgnoreAttr)),
+            n
+        );
+    }
+    function M(t) {
+        var e,
+            n = [],
+            r = document,
+            o = r.documentElement.doScroll,
+            i = (o ? /^loaded|^c/ : /^loaded|^i|^c/).test(r.readyState);
+        (i ||
+            r.addEventListener(
+                "DOMContentLoaded",
+                (e = function () {
+                    for (
+                        r.removeEventListener("DOMContentLoaded", e), i = 1;
+                        (e = n.shift());
+
+                    )
+                        e();
+                })
+            ),
+            i ? setTimeout(t, 0) : n.push(t));
+    }
+    function N(t) {
+        "undefined" != typeof MutationObserver &&
+            new MutationObserver(t).observe(document, {childList: !0, subtree: !0});
+    }
+    try {
+        if (window.FontAwesomeKitConfig) {
+            var D = window.FontAwesomeKitConfig,
+                R = {
+                    detectingConflicts:
+                        D.detectConflictsUntil &&
+                        new Date() <= new Date(D.detectConflictsUntil),
+                    detectionIgnoreAttr: "data-fa-detection-ignore",
+                    fetch: window.fetch,
+                    token: D.token,
+                    XMLHttpRequest: window.XMLHttpRequest,
+                    document: document,
+                },
+                H = document.currentScript,
+                K = H ? H.parentElement : document.head;
+            (function () {
+                var t =
+                        arguments.length > 0 && void 0 !== arguments[0]
+                            ? arguments[0]
+                            : {},
+                    e =
+                        arguments.length > 1 && void 0 !== arguments[1]
+                            ? arguments[1]
+                            : {};
+                return "js" === t.method
+                    ? L(t, e)
+                    : "css" === t.method
+                      ? k(t, e, function (t) {
+                            (M(t), N(t));
+                        })
+                      : void 0;
+            })(D, R)
+                .then(function (t) {
+                    (t.map(function (t) {
+                        try {
+                            K.insertBefore(t, H ? H.nextSibling : null);
+                        } catch (e) {
+                            K.appendChild(t);
+                        }
+                    }),
+                        R.detectingConflicts &&
+                            H &&
+                            M(function () {
+                                H.setAttributeNode(
+                                    document.createAttribute(R.detectionIgnoreAttr)
+                                );
+                                var t = (function (t, e) {
+                                    var n = document.createElement("script");
+                                    return (
+                                        e &&
+                                            e.detectionIgnoreAttr &&
+                                            n.setAttributeNode(
+                                                document.createAttribute(
+                                                    e.detectionIgnoreAttr
+                                                )
+                                            ),
+                                        (n.src = s(t, {
+                                            baseFilename: "conflict-detection",
+                                            fileSuffix: "js",
+                                            subdir: "js",
+                                            minify: t.minify.enabled,
+                                        })),
+                                        n
+                                    );
+                                })(D, R);
+                                document.body.appendChild(t);
+                            }));
+                })
+                .catch(function (t) {
+                    console.error("".concat("Font Awesome Kit:", " ").concat(t));
+                });
+        }
+    } catch (a) {
+        console.error("".concat("Font Awesome Kit:", " ").concat(a));
+    }
+});
diff --git a/audit/static/src/css/form.css b/audit/static/src/css/form.css
new file mode 100644
index 00000000000..fa9b29ebf07
--- /dev/null
+++ b/audit/static/src/css/form.css
@@ -0,0 +1,767 @@
+/* Reset */
+
+.vec_img_centre {
+    display: block;
+    margin-left: auto;
+    margin-right: auto;
+}
+
+.vec_audit_top_box {
+    width: 33%;
+    border-top: 1px solid;
+    padding: 5px 5px 5px 5px;
+}
+
+/* Question section */
+
+.vec_audit_question {
+    border: 1px solid;
+    margin-top: 10px;
+}
+
+.vec_audit_question_label {
+    width: 80%;
+}
+
+:is(
+        .vec_audit_question_label,
+        .vec_audit_question_label_half,
+        .vec_audit_question_notes
+    )
+    :is(b, p) {
+    margin-left: 3px;
+    margin-top: 1px;
+}
+
+.vec_audit_question_yn {
+    width: 20%;
+    border: 1px solid;
+    margin: -1px -1px -1px -1px;
+}
+
+/**
+ * This is applied to the div that Odoo wraps the actual <input> element with
+ * The goal is to center the checkbox inside the box defined above
+ */
+.vec_audit_question_yn_field {
+    width: 100%;
+    height: 100%;
+}
+
+.vec_audit_question_yn_field div.form-check {
+    padding-left: 0px;
+    margin-left: 15%;
+    position: relative;
+    width: 70%;
+    margin-top: 10px;
+    height: 25px;
+}
+
+.vec_audit_question_half {
+    border: 1px solid;
+    margin-top: 10px;
+}
+
+.vec_audit_question_label_half {
+    width: 40%;
+    border: 1px solid;
+    margin: -1px -1px -1px -1px;
+}
+
+.vec_audit_question_yn_half {
+    width: 10%;
+    border: 1px solid;
+    margin: -1px -1px -1px -1px;
+}
+
+.vec_audit_question_notes {
+    width: 100%;
+    border: 1px solid;
+    margin: -1px -1px -1px -1px;
+}
+/**
+ * This is the only way to target a checkbox, since Odoo applies any classes
+ * on the <field> element to a wrapper div.  It also produces a label for us
+ * so we can also target this for custom viewing
+ */
+:is(.vec_audit_question_yn, .vec_audit_question_yn_half) input[type="checkbox"] {
+    display: none;
+}
+
+:is(.vec_audit_question_yn, .vec_audit_question_yn_half)
+    input[type="checkbox"]
+    + label {
+    transform: skew(-10deg);
+    transition: all 0.5s ease;
+    border-radius: 5px;
+    border: 1px;
+    width: 100%;
+    height: 100%;
+    background-color: #de3b36;
+    color: #eeeeee;
+    /* font-weight: bold; */
+    opacity: 0.9;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    box-shadow: 1px 1px 1px rgba(0, 0, 0, 0.2);
+}
+
+:is(.vec_audit_question_yn, .vec_audit_question_yn_half)
+    input[type="checkbox"]
+    + label::after {
+    content: "FAILED";
+}
+
+:is(.vec_audit_question_yn, .vec_audit_question_yn_half)
+    input[type="checkbox"]:checked
+    + label {
+    background-color: #48a858;
+}
+
+:is(.vec_audit_question_yn, .vec_audit_question_yn_half)
+    input[type="checkbox"]:checked
+    + label::after {
+    content: "PASSED";
+}
+
+/* Snapshot page */
+.o_action_manager {
+    overflow-y: scroll !important;
+}
+
+input[type="range"] {
+    /* removing default appearance */
+    -webkit-appearance: none;
+    appearance: none;
+    /* creating a custom design */
+    width: 100%;
+    cursor: pointer;
+    outline: none;
+    /*  slider progress trick  */
+    overflow: hidden;
+    border-radius: 16px;
+}
+
+/* Styling the slider, first we style the `track` */
+input[type="range"]::-webkit-slider-runnable-track {
+    /* removing default appearance */
+    -webkit-appearance: none;
+    appearance: none;
+    /* creating a custom design */
+    cursor: pointer;
+    outline: none;
+    height: 10px;
+    max-width: 180px;
+    background: #0c2d57;
+    border-radius: 16px;
+}
+
+/* Now we style the thumb */
+input[type="range"]::-webkit-slider-thumb {
+    /* removing default appearance */
+    -webkit-appearance: none;
+    appearance: none;
+    /* creating a custom design */
+    height: 170px;
+    width: 15px;
+    background-color: #fc6736;
+    border-radius: 50%;
+}
+
+.questions-form-body {
+    overflow-y: auto;
+    /*This calc is super important, if not present the scrolling area will be the entire page so some data won't show*/
+    height: calc(100% - 50px);
+    min-height: 150px;
+    display: flex;
+    justify-content: center;
+    flex-direction: column;
+    border-style: hidden;
+
+    @media screen and (max-width: 288px) {
+        height: auto;
+    }
+}
+
+.summary-question-body {
+    border-style: solid !important;
+    border-width: 2px;
+    border-radius: 10px;
+    border-color: lightslategray !important;
+}
+
+.questions-form {
+    overflow-y: auto;
+    height: 100% !important;
+}
+
+.comment-text-box {
+    background-color: RGBA(177, 179, 188);
+    border-style: hidden;
+    border-radius: 5px;
+    max-width: 500px;
+    height: 32px;
+
+    @media screen and (max-width: 600px) {
+        margin-left: 5px;
+    }
+}
+
+.question-answers-select {
+    max-width: 100px;
+    background: #0c2d57 !important;
+    color: aquamarine !important;
+    border-radius: 5px !important;
+    font-weight: 500 !important;
+}
+
+.file-upload-box {
+    max-width: 180px;
+    border-radius: 5px !important;
+    border-style: ridge !important;
+    border-width: 3px !important;
+    background-color: #0c2d57 !important;
+    color: aquamarine !important;
+    font-size: smaller !important;
+}
+
+.questions-container {
+    max-width: 1000px;
+}
+
+.individual-question-card {
+    margin-bottom: 15px;
+    border-radius: 5px !important;
+    border-style: hidden !important;
+}
+
+.question-card-footer {
+    display: flex;
+    flex-direction: row;
+    justify-content: space-between;
+    height: fit-content;
+    margin-top: 10px;
+    border-style: hidden !important;
+    border-radius: 5px !important;
+
+    @media screen and (max-width: 600px) {
+        display: flex;
+        flex-direction: column;
+    }
+}
+
+.edit-button {
+    border-color: #00bbf0 !important;
+    color: #00bbf0 !important;
+}
+
+.edit-button:hover {
+    background-color: #0c2d57 !important;
+}
+
+.question-applicable {
+    background-color: #0c2d57 !important;
+    min-width: 48px;
+}
+
+.upload-picture-form {
+    @media screen and (max-width: 600px) {
+        margin-left: 5px;
+    }
+}
+
+.form-switch {
+    display: flex !important;
+    flex-direction: row;
+    margin-top: auto;
+    margin-right: 220px;
+}
+
+.form-check-input {
+    margin-right: 5px;
+}
+
+.form-check-label {
+    margin-right: 5px;
+}
+
+.question-header {
+    border-style: hidden !important;
+    margin-bottom: 10px !important;
+}
+
+.question-score {
+    display: flex;
+    justify-content: center;
+    min-width: 40px;
+    border-radius: 30px;
+    border-style: solid;
+    border-width: thin;
+    border-color: #48a858;
+    background: transparent;
+    color: #00a09d;
+    font-weight: bold;
+    font-size: smaller;
+}
+
+.question-prompt {
+    margin-bottom: 8px;
+    border-radius: 5px !important;
+    max-width: 400px;
+    background: #00bbf0 !important;
+    color: #22313f !important;
+
+    @media screen and (max-width: 600px) {
+        max-width: 300px;
+    }
+}
+
+.back-to-snapshots {
+    width: fit-content;
+    margin: 10px 0 6px 14px;
+    border-radius: 5px !important;
+    border-color: gold !important;
+    color: gold !important;
+}
+
+.back-to-snapshots:hover {
+    background-color: #0c2d57 !important;
+}
+
+.submit-snapshot-btn {
+    display: flex !important;
+    flex-direction: row !important;
+    width: fit-content;
+    margin: 10px 0 6px 14px;
+    border-radius: 5px !important;
+    border-color: gold !important;
+    color: gold !important;
+}
+
+.submit-snapshot-btn:hover {
+    background-color: #0c2d57 !important;
+}
+
+.questions-font {
+    font-weight: bold;
+}
+
+.image-thumbnail {
+    width: 100px;
+    height: 100px;
+    border-radius: 5px;
+}
+
+.summary-image-thumbnail {
+    display: block;
+    width: 50px;
+    height: 50px;
+    border-radius: 5px;
+}
+
+.locked-icon {
+    font-size: small;
+    color: #fe0000;
+}
+
+.unlocked-icon {
+    font-size: small;
+    color: #6eccaf;
+}
+
+.slider {
+    display: flex;
+    flex-direction: row;
+}
+
+.slider-value {
+    font-weight: bold;
+    margin: 0 0 0 4px;
+}
+
+.snapshot-header-footer {
+    max-width: 497px;
+}
+
+.question-and-icon {
+    display: flex;
+    flex-direction: row-reverse;
+    justify-content: space-between;
+}
+
+.submit-snapshot-modal-header {
+    background-color: crimson;
+}
+
+.submit-snapshot-modal-body {
+    background-color: #f1f2f3;
+}
+
+.submit-snapshot-modal-footer {
+    background-color: #f1f2f3;
+}
+
+.cancel-button {
+    border-style: solid !important;
+    border-width: thin !important;
+    border-color: #0fc9e7 !important;
+    background-color: midnightblue !important;
+    color: aliceblue !important;
+}
+
+.confirm-button {
+    border-style: solid !important;
+    border-width: thin !important;
+    border-color: #03c988 !important;
+    background-color: #00cc66 !important;
+    color: aliceblue !important;
+}
+
+/* Audit Dashboard page */
+.search-bar {
+    display: flex;
+    max-width: fit-content;
+    max-height: 20px;
+    margin-top: 10px;
+}
+
+.create-snapshot {
+    border-radius: 5px !important;
+    border-style: groove !important;
+    border-color: #5fbdff !important;
+    border-width: 3px !important;
+    background-color: #1e56a0 !important;
+    margin: 10px 10px 10px 30px;
+
+    @media screen and (max-width: 600px) {
+        font-size: 9px !important;
+    }
+}
+
+.card-text {
+    @media screen and (max-width: 600px) {
+        display: flex;
+        max-width: fit-content;
+    }
+
+    .actions-column {
+        display: flex;
+        flex-direction: row;
+        /*actions-column has its own media styling*/
+        @media screen and (max-width: 600px) {
+            display: flex !important;
+            flex-direction: row-reverse;
+            flex-wrap: wrap;
+        }
+
+        /*Targeting the save-button nested deep inside the div of `actions-column`*/
+        #save-button {
+            @media screen and (max-width: 600px) {
+                margin-right: 5px;
+            }
+        }
+    }
+}
+
+.snapshot-list-buttons {
+    display: flex;
+    flex-direction: row;
+    justify-content: space-between;
+
+    @media screen and (max-width: 600px) {
+        .view-questions {
+            height: 35px;
+        }
+    }
+}
+
+.snapshot-pagination {
+    max-width: fit-content !important;
+    margin-left: 23px !important;
+    font-weight: 800 !important;
+}
+
+/* Create new Snapshot page */
+
+.create-snapshot-form-body {
+    display: flex;
+    justify-content: center;
+}
+
+.create-snapshot-form {
+    width: 900px;
+    max-height: fit-content;
+    margin: 80px;
+    position: relative;
+}
+
+.section-card-body {
+    display: inline-grid;
+}
+
+.submit-and-create-btn {
+    display: flex;
+    flex-direction: row-reverse;
+    margin-top: 20px;
+}
+
+.inspector-body-box {
+    display: flex;
+    align-items: baseline;
+}
+
+.inspector-inputs {
+    max-width: fit-content;
+    margin-left: 8px;
+}
+
+.inspector-first-last-name-labels {
+    margin-left: 8px;
+}
+
+.answer-questions-btn {
+    display: flex !important;
+    flex-direction: row !important;
+    margin-bottom: 20px;
+    border-radius: 5px;
+
+    .answer-questions-icon {
+        margin-right: 4px;
+        padding-top: inherit;
+    }
+
+    .answer-questions-spinner {
+        margin-left: 8px;
+        font-size: large;
+    }
+}
+
+.btn-general {
+    .btn {
+        border-radius: 5px;
+        font-size: 9px;
+        font-weight: bold;
+    }
+    @media screen and (max-width: 600px) {
+        display: flex;
+        flex: auto;
+        font-size: 9px !important;
+    }
+}
+
+.create-back-to-snapshots {
+    border-color: gold !important;
+    border-radius: 5px !important;
+    color: gold !important;
+    margin-left: 14px;
+    margin-top: 14px;
+}
+
+.create-back-to-snapshots:hover {
+    background-color: #0c2d57 !important;
+}
+
+/* Snapshot List page */
+
+.snapshot-list-table {
+    /* Add some height to get the overflow-y working */
+    height: fit-content;
+    overflow-y: auto;
+
+    /* Targeting `screens` up to a maximum width of 650px, any more will be treated as height: fit-content */
+    @media (max-width: 1210px) {
+        height: calc(100% - 50px);
+        th {
+            display: none;
+        }
+        td:first-child {
+            padding-top: 2rem;
+        }
+        td:last-child {
+            padding-bottom: 2rem;
+        }
+        td {
+            display: block;
+        }
+        td::before {
+            content: attr(data-cell) " - ";
+            font-weight: 700;
+            text-transform: capitalize;
+        }
+    }
+
+    .snapshot-list-table-body {
+        max-width: fit-content;
+        overflow-x: auto;
+    }
+}
+
+.view-questions {
+    height: 30px;
+    @media screen and (max-width: 600px) {
+        font-size: 9px !important;
+    }
+}
+
+.view-questions-button {
+    border-color: deepskyblue !important;
+    border-radius: 32px !important;
+    color: deepskyblue !important;
+    background: #0c2d57 !important;
+    font-weight: bold !important;
+}
+
+.summary-button {
+    background-color: #f5f7f8 !important;
+    border-color: #186f65 !important;
+    border-radius: 32px !important;
+    border-width: 2px !important;
+    color: #22a39f !important;
+}
+
+.question-count-badge {
+    display: flex !important;
+    max-width: fit-content !important;
+    position: relative;
+    left: 70px;
+    top: -27px !important;
+    background: #f96d00 !important;
+    border-style: solid;
+    border-width: medium;
+    font-size: 10px !important;
+
+    @media screen and (max-width: 600px) {
+        position: relative;
+        top: -35px !important;
+        left: 42px;
+        font-size: 8px !important;
+    }
+}
+
+.question-count-badge-value {
+    margin-left: 2px;
+    font-weight: 800;
+    color: #062743;
+}
+
+.section-header {
+    background: #89c4ff !important;
+    border: #113f67 !important;
+    border-radius: 5px !important;
+    color: #38598b !important;
+}
+
+.locks-in-span {
+    background-color: #163020 !important;
+    border-radius: 50%;
+    display: inline-block;
+    height: 22px !important;
+    width: 24px !important;
+    text-align: center;
+}
+
+.snapshot-list-percentage-display {
+    font-weight: 600;
+    font-size: smaller;
+    text-align: center;
+}
+
+/* Summary Page */
+.summary-page {
+    overflow-y: auto;
+    /*This calc is super important, if not present the scrolling area will be the entire page so some data won't show*/
+    height: calc(100% - 50px);
+}
+
+.summary-card-title {
+    display: flex;
+    flex-direction: row;
+    justify-content: space-between;
+    max-width: 440px !important;
+
+    @media screen and (max-width: 380px) {
+        max-width: 300px;
+    }
+}
+
+.summary-table {
+    @media screen and (max-width: 600px) {
+        display: block;
+    }
+}
+
+.summary-question {
+    display: flex;
+    flex-direction: column;
+    font-size: smaller;
+    text-overflow: ellipsis;
+    overflow: hidden;
+    max-width: 120px;
+}
+
+.snapshot-summary-card {
+    border-style: hidden !important;
+    background: dimgrey !important;
+    border-radius: 5px !important;
+    margin: 0 8px 13px 13px;
+    max-width: 440px;
+
+    @media screen and (max-width: 600px) {
+        max-width: 385px;
+    }
+}
+
+.section-score {
+    font-size: small !important;
+    background-color: #0962ea !important;
+    border-radius: 5px !important;
+    color: aliceblue !important;
+    min-width: min-content !important;
+    max-height: 20px;
+}
+
+.final-snapshot-score {
+    font-size: small !important;
+    background-color: #e70000 !important;
+    border-radius: 5px !important;
+    color: aliceblue !important;
+}
+
+.snapshot-final-score-footer {
+    margin: 0 0 13px 13px;
+    max-width: 440px;
+    border-style: hidden;
+    min-width: 400px;
+
+    @media screen and (max-width: 414px) {
+        max-width: 355px !important;
+        min-width: 385px;
+    }
+}
+
+/* xml pages styling */
+.view_snapshot_tree {
+    display: inline-flex;
+    border-style: solid;
+    border-radius: 10px;
+    border-color: darkturquoise;
+    max-width: fit-content;
+    padding-left: 5px;
+    padding-right: 5px;
+    color: darkslateblue;
+}
+
+/* Red border for scores below 90% */
+.view_snapshot_tree.text-danger {
+    border-color: #dc3545 !important;
+    border-width: 3px !important;
+    color: #dc3545 !important;
+}
+
+/* Green border for scores 90% and above */
+.view_snapshot_tree.text-success {
+    border-color: #28a745 !important;
+    border-width: 3px !important;
+    color: #28a745 !important;
+}
diff --git a/audit/static/src/javascript_components/dashboard/create_snapshot.js b/audit/static/src/javascript_components/dashboard/create_snapshot.js
new file mode 100644
index 00000000000..6cba308285f
--- /dev/null
+++ b/audit/static/src/javascript_components/dashboard/create_snapshot.js
@@ -0,0 +1,408 @@
+/** @odoo-module **/
+import {Component, useState, onWillStart, xml} from "@odoo/owl";
+import {useService} from "@web/core/utils/hooks";
+import {createSnapshotInstance} from "./dashboard_helpers";
+
+export class CreateSnapShot extends Component {
+    static template = xml`
+        <!--You have to include the stylesheet below for the icons, if you don't you will be forced to paste the svg-->
+        <script src="https://kit.fontawesome.com/2263bf088c.js" crossorigin="anonymous" />
+
+        <header>
+          <div class="row">
+            <div class="col">
+              <button class="btn btn-outline-warning me-2 create-back-to-snapshots"
+                      t-on-click="() => this.backToSnapshots()">
+                <i class="fa-regular fa-circle-left" style="margin-right: 6px" />Back to Snapshots
+              </button>
+            </div>
+          </div>
+        </header>
+
+        <!--Start of the body of the form-->
+        <body class="create-snapshot-form-body">
+          <!--Added overflow-auto to form, all data doesn't fit into the form so we must be able to scroll-->
+          <div class="create-snapshot-form overflow-auto">
+              <div class="card">
+                  <div class="card-body">
+                    <!--Domain Selector switch-->
+                    <div class="mb-3">
+                      <div class="dropdown">
+                        <button class="btn btn-secondary dropdown-toggle"
+                                type="button"
+                                data-bs-toggle="dropdown"
+                                aria-expanded="false">
+                          Select Domain
+                        </button>
+
+                        <ul class="dropdown-menu dropdown-menu-dark">
+                          <t t-foreach="state.existingDomainNames"
+                             t-as="domainName"
+                             t-key="domainName">
+                             <li t-on-click="() => this.assignStateVariables('domain', domainName)">
+                               <a class="dropdown-item" href="#"><t t-esc="domainName"/></a>
+                             </li>
+                          </t>
+                        </ul>
+                      </div>
+                    </div>
+
+                    <!--The Domain selected will display on the card below-->
+                    <t t-if="state.domainName">
+                        <div class="mb-3">
+                            <div class="card">
+                              <div class="card-body">
+                                  <span class="badge rounded-pill text-bg-primary"
+                                        style="margin-right: 2px"><t t-esc="state.domainName"/>
+                                  </span>
+                              </div>
+                            </div>
+                        </div>
+                    </t>
+                  </div>
+              </div>
+
+              <!--Target Selector switch or Create a new Target-->
+              <div class="card">
+                  <div class="card-body">
+                    <div class="mb-3">
+                      <div class="dropdown">
+                        <button t-attf-class="btn btn-secondary dropdown-toggle {{ state.domainName ? '' : 'disabled' }}"
+                                type="button"
+                                data-bs-toggle="dropdown"
+                                aria-expanded="false">
+                          Select Target
+                        </button>
+
+                        <ul class="dropdown-menu dropdown-menu-dark">
+                          <t t-foreach="state.domainTargetNames"
+                             t-as="targetName"
+                             t-key="targetName">
+                             <li t-on-click="() => this.assignStateVariables('target', targetName)">
+                               <a class="dropdown-item" href="#"><t t-esc="targetName"/></a>
+                             </li>
+                          </t>
+                        </ul>
+                      </div>
+                    </div>
+
+                    <!--The existing target selected will display in the card below-->
+                    <t t-if="state.targetName">
+                        <div class="mb-3">
+                            <div class="card">
+                              <div class="card-body">
+                                  <span class="badge rounded-pill text-bg-primary"
+                                        style="margin-right: 2px"><t t-esc="state.targetName"/>
+                                  </span>
+                              </div>
+                            </div>
+                        </div>
+                    </t>
+                  </div>
+              </div>
+
+              <!--Inspector Details-->
+              <div class="card">
+                  <div class="card-body">
+                    <div class="mb-3">
+                      <div class="dropdown">
+                        <button t-attf-class="btn btn-secondary dropdown-toggle {{ state.targetName ? '' : 'disabled' }}"
+                                type="button"
+                                data-bs-toggle="dropdown"
+                                aria-expanded="false">
+                          Select Inspector
+                        </button>
+                        <ul class="dropdown-menu dropdown-menu-dark">
+                          <t t-foreach="state.existingInspectorNames"
+                             t-as="inspector"
+                             t-key="inspector.id">
+                             <li t-on-click="() => this.assignStateVariables('inspector', inspector.inspectorName)">
+                               <a class="dropdown-item" href="#"><t t-esc="inspector.inspectorName"/></a>
+                             </li>
+                          </t>
+                        </ul>
+                      </div>
+                    </div>
+
+                    <!-- If an existing inspector was selected it will show on the below card-->
+                    <t t-if="state.firstName">
+                        <div class="mb-3">
+                            <div class="card">
+                              <div class="card-body">
+                                  <span class="badge rounded-pill text-bg-primary"
+                                        style="margin-right: 2px"><t t-esc="state.firstName + ' ' + state.lastName"/>
+                                  </span>
+                              </div>
+                            </div>
+                        </div>
+                    </t>
+                  </div>
+              </div>
+
+              <!-- Section Selector switch-->
+              <t t-if="state.domainName and state.targetName">
+                  <div class="card-footer text-body-secondary submit-and-create-btn">
+                      <t t-if="state.domainName and
+                                state.targetName and
+                                state.firstName and
+                                state.lastName">
+                        <!-- Disable button after 1st click to prevent multiple submissions-->
+                        <button t-attf-class="btn btn-outline-danger answer-questions-btn {{ state.submitClicked === true ? 'disabled' : '' }}"
+                          t-on-click="() => this.createNewSnapShot()">
+                          <i class="fa-solid fa-circle-play answer-questions-icon" />Answer Questions
+
+                          <!-- Adding a spinner/loader while the Snapshot is being created and the user redirected to the questions-->
+                          <t t-if="state.submitClicked">
+                            <div class="d-flex align-items-center text-danger answer-questions-spinner">
+                                <div class="spinner-border ms-auto" aria-hidden="true" role="status" />
+                            </div>
+                          </t>
+                        </button>
+                    </t>
+                  </div>
+              </t>
+          </div>
+        </body>
+    `;
+
+    // Javascript of the component
+    static props = {
+        data: {},
+        parentState: "",
+    };
+
+    setup() {
+        this.state = useState({
+            pageName: "createSnapshotHomePage",
+            pageData: {},
+            allDomainInstances: {},
+            allTargetInstances: {},
+            allInspectorInstances: {},
+            existingDomainNames: [],
+            domainTargetNames: [],
+            domainSectionNames: [],
+            existingInspectorNames: [],
+            domainSectionQuestions: [],
+            domainName: "",
+            targetName: "",
+            firstName: "",
+            lastName: "",
+            sectionName: "",
+            submitClicked: false,
+            newSnapShotData: {},
+        });
+
+        // Need this service to retrieve db records
+        this.orm = useService("orm");
+
+        // Get all the snapshot instances just before the page renders.
+        onWillStart(async () => {
+            // Getting all the current domain instances in the DB.
+            await this.getAllDomainInstances().then((result) => {
+                this.state.allDomainInstances = result;
+                for (const domain of this.state.allDomainInstances) {
+                    this.state.existingDomainNames.push(domain.name);
+                }
+            });
+
+            // Getting all the current target instances in the DB.
+            await this.getAllTargetInstances().then((result) => {
+                this.state.allTargetInstances = result;
+            });
+
+            // Get all existing inspectors
+            await this.getActiveInspectors().then((result) => {
+                this.state.allInspectorInstances = result;
+                for (const inspector of this.state.allInspectorInstances) {
+                    this.state.existingInspectorNames.push({
+                        inspectorName: `${inspector.forename} ${inspector.surname}`,
+                        id: inspector.id,
+                    });
+                }
+            });
+        });
+    }
+
+    getAllDomainInstances() {
+        // Return this.orm.searchRead('audit.domain', [], [])
+        return this.orm.searchRead("audit.domain", [], []).then((result) => {
+            return result.map((domain) => {
+                // Ensure target_ids is populated
+                if (!domain.target_ids.length && domain.target_rel_ids.length) {
+                    domain.target_ids = domain.target_rel_ids;
+                }
+                return domain;
+            });
+        });
+    }
+
+    getActiveInspectors() {
+        return this.orm.searchRead("audit.inspector", [["active", "=", true]], []);
+    }
+
+    getAllTargetInstances() {
+        return this.orm.searchRead("audit.target", [], []);
+    }
+
+    async getTargetIDInstances(targetIDS) {
+        this.state.domainTargetNames = [];
+        const targetInstances = await this.orm.read("audit.target", targetIDS, [
+            "name",
+            "domain_id",
+            "snapshot_ids",
+        ]);
+        targetInstances.forEach((entry) => {
+            this.state.domainTargetNames.push(entry.name);
+        });
+    }
+
+    async getSectionIDInstances(domainID) {
+        let number = 0;
+        this.state.domainSectionNames = [];
+        this.state.domainSectionQuestions = [];
+
+        // First, get (search) the snapshot_section ids we are interested in
+        const sectionIDs = await this.orm.search("audit.snapshot_section", [
+            ["domain_id", "=", domainID],
+        ]);
+
+        // Secondly, see (read) only the attribute values we need for each snapshot_section we are interested in
+        const snapshot_sections = await this.orm.read(
+            "audit.snapshot_section",
+            sectionIDs,
+            ["display_name", "snapshot_question_ids"]
+        );
+
+        for (const snapshot_section of snapshot_sections) {
+            if (
+                !this.state.domainSectionNames.some(
+                    (section) => section.sectionName === snapshot_section.display_name
+                )
+            ) {
+                this.state.domainSectionNames.push({
+                    sectionName: snapshot_section.display_name,
+                    id: snapshot_section.id,
+                });
+
+                const questionIDs = snapshot_section.snapshot_question_ids;
+                if (questionIDs.length > 0) {
+                    const questions = await this.orm.read(
+                        "audit.snapshot_question",
+                        questionIDs,
+                        ["prompt", "snapshot_section_id"]
+                    );
+
+                    questions.forEach((question) => {
+                        const question_data = {
+                            id: number++,
+                            sectionName: question.snapshot_section_id[1],
+                            prompt: question.prompt,
+                        };
+                        this.state.domainSectionQuestions.push(question_data);
+                    });
+                }
+            }
+        }
+    }
+
+    resetStateVariables() {
+        this.state.targetName = "";
+        this.state.sectionName = "";
+    }
+
+    assignStateVariables(option, value) {
+        // Logic for when a domain is selected
+        if (option === "domain") {
+            // First clean out existing data
+            this.state.targetName = "";
+            this.state.sectionName = "";
+            // Now start adding new data
+            this.state.domainName = value;
+            const domainInstance = this.state.allDomainInstances.find(
+                (element) => element.name === value
+            );
+            const combinedTargetIDs = [
+                ...new Set([
+                    ...domainInstance.target_ids,
+                    ...domainInstance.target_rel_ids,
+                ]),
+            ];
+            // Call the relevant function to retrieve the Target instances if there were any target id's for this domain
+            this.getTargetIDInstances(combinedTargetIDs);
+            // Call the relevant function to retrieve the Snapshot section instances for the selected Domain
+            this.getSectionIDInstances(domainInstance.id);
+        }
+
+        // Logic for when a target is selected
+        if (option === "target") {
+            this.state.targetName = value;
+        }
+
+        // Logic for when an inspector is selected or a new one is created
+        if (option === "inspector") {
+            this.state.firstName = value.split(" ")[0];
+            this.state.lastName = value.split(" ")[1];
+        }
+
+        if (option === "section") {
+            this.state.sectionName = value;
+        }
+    }
+
+    async createNewSnapShot() {
+        this.state.submitClicked = true;
+
+        // Find domain object
+        const domainObject = this.state.allDomainInstances.find(
+            (domain) => domain.display_name === this.state.domainName
+        );
+
+        // Find target object, if not found then new target to be created
+        const targetObject = this.state.allTargetInstances.find(
+            (target) => target.name === this.state.targetName
+        );
+
+        // Find inspector object, if none, a new inspector is to be created
+        const inspectorObject = this.state.allInspectorInstances.find(
+            (inspector) =>
+                inspector.forename === this.state.firstName &&
+                inspector.surname === this.state.lastName
+        );
+
+        // Setting state data object which will be sent to the controller to create the new Snapshot Instance
+        this.state.newSnapShotData = {
+            domain_id: domainObject.id,
+            target_id: targetObject ? targetObject.id : null,
+            new_target_name: this.state.targetName,
+            inspector_id: inspectorObject ? inspectorObject.id : null,
+            new_inspector_name: {
+                forename: this.state.firstName,
+                surname: this.state.lastName,
+            },
+        };
+
+        // Call createSnapshotInstance from dashboard_helpers.js to take care of the snapshot creation
+        const newSnapshot = await createSnapshotInstance(this.state.newSnapShotData, {
+            orm: this.orm,
+        });
+
+        setTimeout(() => {
+            // Update the props of the `snapshot` component
+            console.log(
+                "dashboard.js::createSnapshot > state.PageData props ",
+                newSnapshot
+            );
+            this.state.pageData = newSnapshot;
+            // Change page to 'SnapShotInstance' to start answering the questions
+            this.state.pageName = "SnapShotInstance";
+        }, 3000);
+        // Set the correct page in the `dashboard.js/parent` component and also give it the new snapshot data
+        this.props.parentState.pageData = newSnapshot;
+        this.props.parentState.pageName = "SnapShotInstance";
+    }
+
+    backToSnapshots() {
+        this.props.parentState.pageName = "auditHomePage";
+        this.resetStateVariables();
+    }
+}
diff --git a/audit/static/src/javascript_components/dashboard/dashboard.js b/audit/static/src/javascript_components/dashboard/dashboard.js
new file mode 100644
index 00000000000..13096131266
--- /dev/null
+++ b/audit/static/src/javascript_components/dashboard/dashboard.js
@@ -0,0 +1,91 @@
+/** @odoo-module **/
+import {registry} from "@web/core/registry";
+import {Component, onWillStart, useState, xml} from "@odoo/owl";
+import {useService} from "@web/core/utils/hooks";
+import {SnapshotList} from "./snapshot_list";
+import {Snapshot} from "./snapshot";
+import {CreateSnapShot} from "./create_snapshot";
+import {SnapshotSummary} from "./snapshot_summary";
+import {store} from "../../store";
+
+class AuditDashboard extends Component {
+    static template = xml`
+        <!-- A button to create new SnapShot instances. See btn only from audit home page-->
+        <t t-if="state.pageName === 'auditHomePage'">
+          <div style="display: flex; max-width: 500px">
+            <button
+                type="button"
+                class="btn btn-primary create-snapshot"
+                t-on-click="() => this.selectAndCompleteAudit()">
+              Select and Complete Audit
+            </button>
+
+            <div class="search-bar-text input-group search-bar">
+                <!-- Custom Calendar search -->
+                <div class="mx-2"><i class="fa fa-calendar" /></div>
+                <input
+                    type="date"
+                    class="form-control"
+                    t-model="store.searchDate"
+                    t-on-change="() => this.store.executeSearch(this)">
+                </input>
+            </div>
+          </div>
+        </t>
+
+        <!--Note, 'parentState' is always passed in so that child components can manipulate the -->
+        <!--parent via props-->
+        <t t-if="state.pageName === 'SnapShotInstance'">
+          <Snapshot data="state.pageData" parentState="state"/>
+        </t>
+
+        <t t-elif="state.pageName === 'createSnapshotHomePage'">
+          <CreateSnapShot data="state.pageData" parentState="state" />
+        </t>
+
+        <t t-elif="state.pageName === 'SnapshotSummary'">
+          <SnapshotSummary data="state.pageData" parentState="state" />
+        </t>
+
+        <t t-elif="state.pageName !== 'createSnapshotHomePage' and
+                   state.pageName !== 'SnapShotInstance' and
+                   state.pageName !== 'SnapshotSummary'">
+
+        <SnapshotList parentState="state" data="state.pageData" pages="state.pages" />
+        </t>
+    `;
+
+    /** Javascript part of the component */
+    static components = {
+        SnapshotList,
+        Snapshot,
+        CreateSnapShot,
+        SnapshotSummary,
+    };
+    store = useState(store);
+
+    setup() {
+        this.state = useState({
+            pageName: "auditHomePage",
+            pageData: {},
+            pages: null,
+            limit: 15,
+            offset: 1,
+            allSnapshots: {},
+        });
+
+        this.http = useService("http");
+        // The orm service is necessary to call a BE function.
+        this.orm = useService("orm");
+
+        onWillStart(async () => {
+            this.store.executeSearch(this);
+        });
+    }
+
+    selectAndCompleteAudit() {
+        this.state.pageName = "createSnapshotHomePage";
+    }
+}
+
+registry.category("actions").add("audit.dashboard", AuditDashboard);
diff --git a/audit/static/src/javascript_components/dashboard/dashboard_helpers.js b/audit/static/src/javascript_components/dashboard/dashboard_helpers.js
new file mode 100644
index 00000000000..065706e32f3
--- /dev/null
+++ b/audit/static/src/javascript_components/dashboard/dashboard_helpers.js
@@ -0,0 +1,335 @@
+/** @odoo-module **/
+import {Component, useState, xml} from "@odoo/owl";
+import {useService} from "@web/core/utils/hooks";
+import {store} from "../../store";
+
+/**
+ * This method runs when we click "View Questions" so we can load all the sections and questions
+ * for the snapshot being viewed.
+ * @param {*} data
+ * @param {*} api
+ * @returns
+ */
+export async function orderCurrentSnapshotInstanceData(data, api) {
+    const sectionsAndQuestions = [];
+
+    const sectionIDs = data[0]
+        ? data[0].snapshot_section_ids
+        : data.snapshot_section_ids;
+    // Find updated associated snapshot_questions for each snapshot_section_id
+    const questions = await api.orm.searchRead(
+        "audit.snapshot_question",
+        [["snapshot_section_id", "in", sectionIDs]],
+        []
+    );
+
+    // Fetch any attachments as necessary
+    const questionIds = questions.map((question) => question.id);
+    const attachments = await api.orm.searchRead(
+        "ir.attachment",
+        [
+            ["res_id", "in", questionIds],
+            ["res_model", "=", "audit.snapshot_question"],
+            ["res_field", "=", "image"],
+        ],
+        // Exclude binary data fields
+        ["id", "res_id", "res_model", "res_field", "name", "mimetype", "file_size"]
+    );
+    // Add number, and join attachments
+    questions.forEach((question) => {
+        question.number = question.id;
+        question.img_src = null;
+        attachments.forEach((attachment) => {
+            if (attachment.res_id === question.id) {
+                // Construct the image URL using the attachment ID instead of binary data
+                question.img_src = `/web/image/${attachment.id}`;
+            }
+        });
+    });
+    let snapshotSectionNames = questions.map((entry) => entry.snapshot_section_id[1]);
+    snapshotSectionNames = snapshotSectionNames.filter(
+        (value, index) => snapshotSectionNames.indexOf(value) === index
+    );
+
+    // For each snapshot_section_name we want the questions belonging to it
+    let snapshotSectionQuestions = [];
+    for (const sectionName of snapshotSectionNames) {
+        for (const question of questions) {
+            if (question.snapshot_section_id[1] === sectionName) {
+                snapshotSectionQuestions.push(question);
+            }
+        }
+        sectionsAndQuestions.push({
+            snapshot_section_name: sectionName,
+            questions: snapshotSectionQuestions,
+            locked: data[0] ? data[0].locked : data.locked,
+            snapshot_id: data[0] ? data[0].id : data.id,
+        });
+        snapshotSectionQuestions = [];
+    }
+    return sectionsAndQuestions;
+}
+
+/**
+ * This method runs when we click "Answer Questions", it will call the ORM, audit.snapshot class,
+ * which will create a new Snapshot Instance.
+ * @param {*} data
+ * @param {*} api
+ * @returns
+ */
+export async function createSnapshotInstance(data, api) {
+    try {
+        const orm = api.orm;
+        const [snapshotId] = await orm.create("audit.snapshot", [data]);
+
+        // Validate response
+        if (!snapshotId) {
+            throw new Error("Failed to create snapshot (no ID returned)");
+        }
+
+        // Fetch newly created Snapshot
+        const snapshot = await orm.searchRead(
+            "audit.snapshot",
+            [["id", "=", snapshotId]],
+            []
+        );
+
+        // Validate snapshot
+        if (!snapshot || snapshot.length === 0) {
+            throw new Error(
+                `Created snapshot not found in database with ID: ${snapshotId}`
+            );
+        }
+        return await orderCurrentSnapshotInstanceData(snapshot, api);
+    } catch (error) {
+        console.error(
+            "dashboard_helpers.js::createSnapshotInstance > Error creating snapshot:",
+            error
+        );
+        throw error;
+    }
+}
+
+/**
+ * Call the audit.snapshot class's `write` function to update a specific Snapshot instance
+ * @param {*} sectionsWithQuestions
+ * @param {*} submitSnapshot
+ * @param {*} api
+ * @returns
+ */
+export async function submit(sectionsWithQuestions, submitSnapshot, api) {
+    // If this is a submit request, first lock the snapshot
+    if (submitSnapshot) {
+        await api.orm.call(
+            "audit.snapshot",
+            "write",
+            [sectionsWithQuestions[0].snapshot_id],
+            {
+                vals: {locked: true},
+            }
+        );
+        return true;
+    }
+    return false;
+}
+
+/**
+ * Call toggle_not_applicable from the audit.snapshot class to mark a snapshot question
+ * as not applicable.
+ * @param {*} question
+ * @param {*} api
+ * @returns
+ */
+export async function questionApplicable(question, api) {
+    const result = await api.orm.call(
+        "audit.snapshot_question",
+        "toggle_not_applicable",
+        [question.id],
+        {}
+    );
+    question.applicable = result.applicable;
+}
+
+/**
+ * Retrieve all Snapshot records from the database.
+ * @param {*} api
+ * @returns
+ */
+export async function allSnapshotInstances(api) {
+    return api.orm.searchRead("audit.snapshot", [], []);
+}
+
+/**
+ * Load the SnapshotQuestions for each SnapshotSection.
+ * @param {*} section_ids
+ * @param api
+ * @returns
+ */
+export async function getSectionSnapshotQuestions(section_ids, api) {
+    const questions = {};
+    for (const sectionId of section_ids) {
+        const section_id_questions = await api.orm.searchRead(
+            "audit.snapshot_question",
+            [["snapshot_section_id", "=", sectionId]],
+            []
+        );
+
+        if (section_id_questions) {
+            questions[sectionId] = section_id_questions;
+        }
+    }
+    return questions;
+}
+
+/**
+ * For each snapshot, retrieve its Snapshot Sections, then for each Snapshot Section,
+ * retrieve its Snapshot Questions.  Bundle it all together and return the result.
+ * @param {*} allSnapshots
+ * @param api
+ * @returns
+ */
+export async function prepareAllSnapshotQuestions(allSnapshots, api) {
+    for (const snapshot of allSnapshots) {
+        const sectionIds = snapshot.snapshot_section_ids;
+        const questions = await getSectionSnapshotQuestions(sectionIds, api);
+        Object.assign(snapshot, {questions});
+    }
+    return allSnapshots;
+}
+
+/**
+ * `readAsDataURL()` produces `data:<mime>;base64,<payload>`. Odoo `Image` fields expect
+ * a plain base64 string; the server rejects a full data URL.
+ * @param {string|boolean|undefined} value
+ * @returns {string|boolean|undefined}
+ */
+function imageValueForOdooWrite(value) {
+    if (!value || typeof value !== "string" || !value.startsWith("data:")) {
+        return value;
+    }
+    const marker = ";base64,";
+    const index = value.indexOf(marker);
+    if (index === -1) {
+        return value;
+    }
+    return value.slice(index + marker.length);
+}
+
+/**
+ * Whenever any part of a Snapshot Question changes or is updated, the change is immediately saved.
+ * The purpose of this function is to take care of auto saving Snapshot Questions.
+ * @param {*} question
+ * @param {*} image
+ * @param {*} api
+ */
+export function autoSaveQuestionChanges(question, image, api) {
+    // We will update a snapshot whether it is locked or not - Sam's request
+    api.orm
+        .searchRead(
+            "audit.snapshot",
+            [["snapshot_section_ids", "in", question.snapshot_section_id[0]]],
+            []
+        )
+        .then(() => {
+            let new_values = {};
+            // Have to do a fresh lookup of the question because we don't know if the internal `save` has been called on it
+            api.orm
+                .searchRead("audit.snapshot_question", [["id", "=", question.id]], [])
+                .then((rows) => {
+                    const row = rows[0];
+                    if (question.comment === row.comment) {
+                        // eslint-disable-next-line no-self-assign
+                        question.comment = question.comment;
+                    } else if (
+                        question.comment &&
+                        row.comment &&
+                        question.comment !== row.comment
+                    ) {
+                        question.comment = row.comment;
+                    }
+                    question.image = row.image;
+
+                    new_values = {
+                        comment: question.comment,
+                        answer_yn: question.answer_yn,
+                        answer_star: question.answer_star,
+                        answer_perc: question.answer_perc,
+                        image: image ? imageValueForOdooWrite(image) : question.image,
+                    };
+
+                    api.orm.call("audit.snapshot_question", "write", [question.id], {
+                        vals: new_values,
+                    });
+                });
+        });
+}
+
+export class PageComponent extends Component {
+    static template = xml`
+    <nav aria-label="Page navigation">
+      <ul class="pagination justify-content-center snapshot-pagination">
+
+        <!-- 'Previous' page Button-->
+        <li t-attf-class="page-item {{ store.searchPage === 1 ? 'disabled' : '' }}">
+          <a class="page-link"
+             t-on-click="() => this.updateCurrentPage('previous')">Previous</a>
+        </li>
+
+          <!--Not showing all pages, overflow of pages displayed as an elipse-->
+          <t t-foreach="store.visiblePages" t-as="page" t-key="page_index">
+            <t t-if="page === '...'">
+                <li class="page-item disabled">
+                    <span class="page-link">...</span>
+                </li>
+            </t>
+
+            <t t-else="">
+                <li t-attf-class="page-item {{ store.searchPage === page ? 'active' : '' }}">
+                    <a class="page-link"
+                       href="#"
+                       t-on-click="(ev) => this.onPageNumberClick(page, ev)">
+                        <t t-esc="page"/>
+                    </a>
+                </li>
+            </t>
+          </t>
+
+        <!-- 'Next' page Button-->
+        <li t-attf-class="page-item {{ store.searchPage === store.numberOfPages ? 'disabled' : '' }}">
+          <a class="page-link"
+             t-on-click="() => this.updateCurrentPage('next')">Next</a>
+        </li>
+      </ul>
+    </nav>
+  `;
+
+    static components = {};
+    store = useState(store);
+
+    setup() {
+        this.orm = useService("orm");
+        this.state = useState({pageName: "SnapShotList"});
+    }
+
+    onPageNumberClick(page, ev) {
+        if (ev) {
+            ev.preventDefault();
+        }
+        this.updateCurrentPage(page);
+    }
+
+    updateCurrentPage(pageNumber) {
+        const cur = this.store.searchPage;
+        const next =
+            pageNumber === "previous"
+                ? Math.max(1, cur - 1)
+                : pageNumber === "next"
+                  ? Math.min(this.store.numberOfPages, cur + 1)
+                  : pageNumber;
+        if (next === cur) {
+            return;
+        }
+        this.store.searchPage = next;
+        this.store.executeSearch(this);
+    }
+}
diff --git a/audit/static/src/javascript_components/dashboard/snapshot.js b/audit/static/src/javascript_components/dashboard/snapshot.js
new file mode 100644
index 00000000000..c319fa91b05
--- /dev/null
+++ b/audit/static/src/javascript_components/dashboard/snapshot.js
@@ -0,0 +1,402 @@
+/** @odoo-module **/
+import {Component, onWillStart, onWillUpdateProps, useState, xml} from "@odoo/owl";
+// In order to get data from our database we need a service, hence the import of useService below
+import {useService} from "@web/core/utils/hooks";
+import {store} from "../../store";
+import {autoSaveQuestionChanges, questionApplicable, submit} from "./dashboard_helpers";
+
+export class Snapshot extends Component {
+    static template = xml`
+        <script src="https://kit.fontawesome.com/2263bf088c.js" crossorigin="anonymous" />
+
+        <!-- A bunch of cards, each displays a single question -->
+        <div class="snapshot-header-footer">
+            <button class="btn btn-outline-warning back-to-snapshots"
+                    t-on-click="() => this.backToAuditDashboard()">
+                <i class="fa-regular fa-circle-left" style="margin-right: 6px" />Back To Snapshots
+            </button>
+        </div>
+
+        <div class="questions-form-body">
+            <div class="questions-form">
+              <div class="row m-2">
+                  <div class="col">
+
+                      <t t-foreach="this.state.questions"
+                         t-as="section"
+                         t-key="section.snapshot_section_name">
+                          <div class="row questions-container">
+                              <div class="col-sm-6 mb-3 mb-sm-0">
+
+                                <t t-if="(typeof section.snapshot_section_name === 'string')">
+                                    <div class="alert alert-primary section-header"
+                                         role="alert"
+                                         style="font-size: large">
+                                      <t t-esc="section.snapshot_section_name" />
+                                    </div>
+                                </t>
+                              </div>
+                          </div>
+
+                          <!--For each section, display its questions separately-->
+                          <t t-foreach="section.questions"
+                             t-as="question"
+                             t-key="question.number">
+                              <div class="row questions-container">
+                                  <div class="col-sm-6 mb-3 mb-sm-0 question-container-card">
+                                    <!--For each question a card is made, the card contains all the info for the question-->
+                                    <div class="card individual-question-card">
+                                      <!--Making the card body of a question ghostwhite if the question is no longer applicable-->
+                                      <div class="card-body"
+                                           t-attf-style="{{ question.applicable ? '' : 'background: ghostwhite !important' }}; border-style: solid; border-color: #89c4ff; border-radius: 5px;">
+                                          <div class="question-and-icon">
+                                            <!--Logic on icon will display a locked or an unlocked padlock depending on if the snapshot has been submitted-->
+                                            <span class="locks-in-span">
+                                                <i t-attf-class="{{ state.allQuestionsLocked ? 'locked-icon fa-solid fa-lock' : 'unlocked-icon fa-solid fa-lock-open' }}" />
+                                            </span>
+                                            <!--Making the question prompt also ghostwhite if the question is no longer applicable-->
+                                            <div class="badge text-wrap question-prompt"
+                                                 t-attf-style="{{ question.applicable ? '' : 'background: ghostwhite !important' }}">
+                                                <h4 class="card-text"><t t-esc="question.prompt" /></h4>
+                                            </div>
+                                          </div>
+
+                                        <div class="card-text">
+                                            <p>
+                                                <t t-if="question.answer_type === 'boolean'">
+                                                  <select class="form-select from-control question-answers-select needs-validation"
+                                                          id="answerTypeControlCheck"
+                                                          aria-label="Yes/No questions"
+                                                          t-on-change="() => this.autoSaveQuestion(question)"
+                                                          t-model="question.answer_yn">
+                                                      <option value="" />
+                                                      <option value="0">No</option>
+                                                      <option value="1">Yes</option>
+                                                  </select>
+                                                </t>
+
+                                                <t t-elif="question.answer_type === 'integer'">
+                                                  <select class="form-select question-answers-select needs-validation"
+                                                          aria-label="Star rated questions"
+                                                          t-on-change="() => this.autoSaveQuestion(question)"
+                                                          t-model="question.answer_star">
+                                                      <option value=""/>
+                                                      <option value="1">★</option>
+                                                      <option value="2">★★</option>
+                                                      <option value="3">★★★</option>
+                                                      <option value="4">★★★★</option>
+                                                  </select>
+                                                </t>
+
+                                                <t t-elif="question.answer_type === 'float'">
+                                                    <div class="slider">
+                                                        <input id="percentageSlider"
+                                                               type="range"
+                                                               style="max-width: fit-content; background: border-box"
+                                                               min="0"
+                                                               max="100"
+                                                               step="1"
+                                                               value="0"
+                                                               t-on-change="() => this.autoSaveQuestion(question)"
+                                                               t-model="question.answer_perc" />
+                                                        <p class="slider-value"><t t-esc="question.answer_perc + '%'" /></p>
+                                                    </div>
+                                                </t>
+                                            </p>
+                                        </div>
+
+                                        <p class="card-text questions-font">Comments:
+                                            <t t-if="question.comment.length >= 1">
+                                                <p t-on-click="() => { question.comment = '', this.autoSaveQuestion(question) }">
+                                                    <t t-esc="question.comment ? question.comment.slice(0, 30) + '...' : ''" />
+                                                </p>
+                                            </t>
+
+                                            <t t-else="''">
+                                              <div>
+                                                  <input placeholder="Type comments here..."
+                                                         class="comment-text-box"
+                                                         type="text"
+                                                         t-on-change="() => this.autoSaveQuestion(question)"
+                                                         t-model.lazy="question.comment"/>
+                                              </div>
+                                            </t>
+                                        </p>
+
+                                        <p class="card-text questions-font">
+                                            <t t-if="question.img_src">
+                                              <div class="my-2">
+                                                <img style="width: 120px;" t-att-src="question.img_src" />
+                                              </div>
+                                              <div>Change picture</div>
+                                            </t>
+
+                                            <t t-else="">
+                                              <div>Upload a picture</div>
+                                            </t>
+
+                                            <form class="upload-picture-form"
+                                                  method="post"
+                                                  enctype="multipart/form-data">
+                                              <input
+                                                  class="form-control form-control-sm file-upload-box"
+                                                  type="file"
+                                                  t-on-change="event => { this.onChangeAttach(event, {...question}), this.convertBase64ToFile(event, question) }"
+                                                  name="image-upload"
+                                                  accept="image/*"/>
+
+                                            </form>
+                                        </p>
+
+                                        <!--"onerror" is added otherwise, if no image was chosen to be uploaded it leaves behind an ugly empty box, note the use of "this"-->
+                                        <img t-attf-id="{{ question.id }}"
+                                             class="image-thumbnail"
+                                             src=""
+                                             onerror="this.style.display='none'" />
+
+                                        <div class="card-footer bg-light question-card-footer">
+                                          <!--A switch to select a question to be applicable or not-->
+                                          <div class="form-check form-switch">
+                                              <div class="spinner-border text-primary"
+                                                   role="status"
+                                                   t-attf-style="{{ !state.questionApplicableLoader ? 'display: none' : '' }}" />
+
+                                              <input class="form-check-input question-applicable"
+                                                     t-attf-checked="{{ (!!question.applicable) }}"
+                                                     type="checkbox"
+                                                     role="switch"
+                                                     id="flexSwitchCheckDefault"
+                                                     t-on-click="() => this.questionApplicable(question)"/>
+
+                                              <!--The label must change according to the "applicable" status of the question-->
+                                              <t t-if="question.applicable">
+                                                  <label class="form-check-label"
+                                                         for="flexSwitchCheckDefault"
+                                                         t-attf-style="{{ state.questionApplicableLoader ? 'display: none' : ''}}">Applicable
+                                                  </label>
+                                              </t>
+                                              <t t-else="">
+                                                  <label class="form-check-label"
+                                                         for="flexSwitchCheckDefault"
+                                                         t-attf-style="{{ state.questionApplicableLoader ? 'display: none' : ''}}">Excluded
+                                                  </label>
+                                              </t>
+                                          </div>
+                                        </div>
+                                      </div>
+                                    </div>
+                                  </div>
+                              </div>
+                          </t>
+                      </t>
+                  </div>
+              </div>
+            </div>
+
+            <div class="snapshot-header-footer">
+                <!--Button to call a save on every question on the page -->
+                <button
+                    t-attf-class="btn btn-outline-warning submit-snapshot-btn {{ state.allQuestionsLocked ? 'disabled' : '' }}"
+                    data-bs-toggle="modal"
+                    data-bs-target="#submitSnapshotModal">
+                    <i class="fa-regular fa-floppy-disk" style="margin: 3px;" />Submit Snapshot
+                    <t t-if="state.submitSnapshot">
+                        <div class="d-flex align-items-center text-warning" style="margin-left: 8px;">
+                            <div class="spinner-border ms-auto"
+                                 style="font-size: medium;"
+                                 aria-hidden="true"
+                                 role="status" />
+                        </div>
+                    </t>
+
+                </button>
+                <!--The below modal will pop-up/modal if the user clicks on the above button -->
+                <div class="modal fade" id="submitSnapshotModal">
+                  <div class="modal-dialog">
+                    <div class="modal-content">
+                      <div class="modal-header submit-snapshot-modal-header">
+                        <h1 class="modal-title fs-5">Final Submission</h1>
+                        <button type="button"
+                                class="btn-close"
+                                data-bs-dismiss="modal"
+                                aria-label="Close" />
+                      </div>
+
+                      <div class="modal-body submit-snapshot-modal-body">
+                        <p>The Snapshot audit will be submitted as it is, you will still be able to make changes to the questions. Do you wish to proceed?</p>
+                      </div>
+
+                      <div class="modal-footer submit-snapshot-modal-footer">
+                        <!-- You have to add "data-bs-dismiss" to both "cancel" and "confirm" buttons else the model won't close -->
+                        <button type="button"
+                                class="btn btn-secondary cancel-button"
+                                data-bs-dismiss="modal">cancel
+                        </button>
+
+                        <button
+                            id="confirmBtn"
+                            type="button"
+                            class="btn btn-success confirm-button"
+                            data-bs-dismiss="modal"
+                            t-on-click="() => this.submitSnapshot()">
+                            CONFIRM
+                        </button>
+
+                      </div>
+                    </div>
+                  </div>
+                </div>
+            </div>
+        </div>
+    `;
+
+    // Javascript part of the component
+    store = useState(store);
+
+    static props = {
+        data: {},
+        parentState: "",
+    };
+
+    setup() {
+        this.state = useState({
+            pageName: "SnapShotInstance",
+            pageData: {},
+            questions: {},
+            successfulEdit: false,
+            allQuestionsLocked: false,
+            submitSnapshot: false,
+            defaultCount: 0,
+            questionApplicableLoader: false,
+        });
+
+        this.orm = useService("orm");
+        // You need the below action called `action` in order to view a separate action window
+        this.action = useService("action");
+
+        onWillStart(async () => {
+            this.state.pageData = this.props.data;
+            // Set `state.questions` else nothing will display
+            this.state.questions = this.props.data;
+            // Get the snapshot_id from the data, look up the snapshot and check if it is locked or not
+            if (this.props.data[0].snapshot_id) {
+                const snapshot = await this.orm.searchRead(
+                    "audit.snapshot",
+                    [["id", "=", this.props.data[0].snapshot_id]],
+                    []
+                );
+                if (snapshot) {
+                    const result = snapshot[0];
+                    if (result.locked) {
+                        this.state.allQuestionsLocked = true;
+                    }
+                }
+            }
+        });
+
+        onWillUpdateProps(async (nextProps) => {
+            // Get the updated pageData from the parent component via `nextProps`
+            this.state.pageData = nextProps.data;
+            this.state.questions = nextProps.data;
+        });
+    }
+
+    async toQuestionFormView(question) {
+        this.action.doAction({
+            name: "Question Details",
+            type: "ir.actions.act_window",
+            res_model: "audit.snapshot_question",
+            views: [[false, "form"]],
+            target: "new",
+            res_id: question.id,
+        });
+    }
+
+    async backToAuditDashboard() {
+        await this.store.executeSearch(this, {force: true});
+        this.props.parentState.pageName = "auditHomePage";
+    }
+
+    convertFileToBase64 = (file) => {
+        return new Promise((resolve, reject) => {
+            const fileReader = new FileReader();
+            fileReader.readAsDataURL(file);
+
+            fileReader.onload = () => {
+                resolve(fileReader.result);
+            };
+
+            fileReader.onerror = (error) => {
+                reject(error);
+            };
+        });
+    };
+
+    convertBase64ToFile(event, question) {
+        const uploadedImage = document.getElementById(question.id);
+        const blob = new Blob([event.target.files[0]], {type: "image/jpeg"});
+        const blobURL = URL.createObjectURL(blob);
+        // Have to have `.style.display = block` here and not in the css else the thumbnail won't show
+        uploadedImage.style.display = "block";
+        uploadedImage.src = blobURL;
+    }
+
+    // There is a t-on-change directive for the <input/> html tag which ensures that when a file is attached
+    // a change event is fired, that change event is `captured` here so that we can encode the image before
+    // we try and submit it to the BE.
+    async onChangeAttach(event, question) {
+        const pictureFile = event.target.files[0];
+        const base64EncodedFile = await this.convertFileToBase64(pictureFile);
+        // Save the new image to the snapshot question
+        this.autoSaveQuestion(question, base64EncodedFile);
+    }
+
+    // Select between Applicable and Excluded for a particular question
+    async questionApplicable(question) {
+        await questionApplicable(question, {orm: this.orm});
+    }
+
+    autoSaveQuestion(question, image) {
+        autoSaveQuestionChanges(question, image, {orm: this.orm});
+    }
+
+    async submitSnapshot() {
+        // Before we allow a submit we must check that relevant fields have been completed
+        const errors = document.querySelectorAll(".needs-validation");
+        let amountOfErrors = errors.length;
+
+        errors.forEach((error) => {
+            if (error.value === "") {
+                error.style =
+                    "border-style: groove; border-color: red !important; border-radius: 5px !important; border-width: 3px !important";
+            } else {
+                error.style =
+                    "border-style: groove; border-color: green !important; border-radius: 5px !important; border-width: 3px !important";
+                amountOfErrors -= 1;
+            }
+        });
+
+        // If all validation is good then we can submit the snapshot
+        if (amountOfErrors <= 0) {
+            try {
+                // Set this to get the spinner turning
+                this.state.submitSnapshot = true;
+                // Submit the snapshot and lock it
+                await submit(this.state.questions, true, {orm: this.orm});
+                // Refresh the search
+                this.store.resetSearchFields();
+                this.store.executeSearch({orm: this.orm});
+                // Set the page of the parent component (dashboard.js) to `auditHomePage`
+                this.props.parentState.pageName = "auditHomePage";
+            } catch (e) {
+                console.log("snapshot.js::submitSnapshot::");
+                throw new Error(
+                    `Something went wrong while trying to submit the snapshot: , ${e}`
+                );
+            }
+        } else {
+            // eslint-disable-next-line no-alert -- simple validation message for the dashboard
+            window.alert("Some of the required fields in red have not been completed!");
+        }
+    }
+}
diff --git a/audit/static/src/javascript_components/dashboard/snapshot_list.js b/audit/static/src/javascript_components/dashboard/snapshot_list.js
new file mode 100644
index 00000000000..c73db9b4a97
--- /dev/null
+++ b/audit/static/src/javascript_components/dashboard/snapshot_list.js
@@ -0,0 +1,143 @@
+/** @odoo-module **/
+import {Component, useState, onWillStart, onWillUpdateProps, xml} from "@odoo/owl";
+// In order to get data from our database we need a service, hence the import of useService below
+import {useService} from "@web/core/utils/hooks";
+import {
+    orderCurrentSnapshotInstanceData,
+    PageComponent,
+    prepareAllSnapshotQuestions,
+} from "./dashboard_helpers";
+import {store} from "../../store";
+
+export class SnapshotList extends Component {
+    static template = xml`
+        <!-- A table to display all Audit Snapshot records and their relevant information -->
+        <div class="snapshot-list-table">
+            <body class="snapshot-list-table-body">
+              <div class="row m-2">
+                  <div class="col">
+                      <table class="table table-striped table-hover">
+                        <thead>
+                            <!-- This first row is for all the column headers of the table-->
+                            <tr>
+                              <th scope="col">Display Name</th>
+                              <th scope="col">Target</th>
+                              <th scope="col">Domain</th>
+                              <th scope="col">Inspector</th>
+                              <th scope="col">Status</th>
+                              <th scope="col">Percentage Score</th>
+                              <th scope="col">Actions</th>
+                            </tr>
+                        </thead>
+
+                        <tbody>
+                          <tr
+                              t-foreach="store.searchedSnapshots"
+                              t-as="snapshotInstance"
+                              t-key="snapshotInstance.id">
+                              <td data-cell="name" t-esc="snapshotInstance.display_name.substring(0, snapshotInstance.display_name.indexOf(' ')) + ' ' + snapshotInstance.date_conducted.substring(8, 10) + snapshotInstance.date_conducted.substring(4, 7) + '-' + snapshotInstance.date_conducted.substring(0, 4)" />
+                              <td data-cell="target" t-esc="snapshotInstance.target_id[1]" />
+                              <td data-cell="domain" t-esc="snapshotInstance.domain_id[1]" />
+                              <td data-cell="inspector" t-esc="snapshotInstance.inspector_id[1]" />
+                              <td data-cell="status">
+                                  <span class="locks-in-span">
+                                      <i t-attf-class="{{ snapshotInstance.locked ? 'fa-solid fa-lock' : 'fa-solid fa-lock-open' }}"
+                                         t-attf-style="{{ snapshotInstance.locked ? 'color: #FE0000' : 'color: #6ECCAF' }}" />
+                                  </span>
+                              </td>
+                              <td data-cell="score">
+                                <span class="snapshot-list-percentage-display"
+                                      t-attf-style="{{ ((snapshotInstance.percentage_score * 100) >= 85 and snapshotInstance.locked) ? 'color: #6ECCAF' : 'color: #FE0000' }}"
+                                      t-esc="this.showPassOrFail(snapshotInstance)" />
+                                <span class="snapshot-list-percentage-display"
+                                      t-esc="(snapshotInstance.percentage_score * 100).toFixed(0) + '%'" />
+                              </td>
+                              <td data-cell="actions" class="snapshot-list-buttons">
+                                  <!-- If you don't call the function below like it is done below, then the function call acts like a computed property in Vue-->
+                                  <!-- in that it gets called straight away and multiple times.  Notice also then when we call the function we use "this" otherwise-->
+                                  <!-- owl thinks we are re-declaring a function and does very weird things-->
+                                  <button class="btn btn-outline-info me-2 view-questions view-questions-button"
+                                          t-on-click="() => this.viewSnapShotQuestions(snapshotInstance)">
+                                      <i class="fa-solid fa-glasses" style="margin-right: 6px" />View Questions
+                                  </button>
+    <!--                          Only show this button if an audit instance is locked, ergo, it has been submitted-->
+                                  <t t-if="snapshotInstance.locked">
+                                      <button class="btn btn-outline-secondary view-questions summary-button"
+                                              t-on-click="() => this.viewSnapshotSummary(snapshotInstance)">
+                                          <i class="fa-solid fa-book" style="margin-right: 4px"/>Summary
+                                          <!-- Only display this badge if the snapshot has questions with comments filled in-->
+                                          <t t-if="snapshotInstance.questions_with_comments > 0">
+                                              <span class="badge question-count-badge rounded-pill">
+                                                <div class="question-count-badge-value" t-esc="snapshotInstance.questions_with_comments" />
+                                              </span>
+                                          </t>
+                                      </button>
+                                  </t>
+                              </td>
+                          </tr>
+                        </tbody>
+                      </table>
+                  </div>
+              </div>
+            </body>
+            <!--Calling the PageComponent to take care of pagination-->
+            <PageComponent pages="state.pages" currentPage="state.currentPage" />
+        </div>
+    `;
+    static components = {PageComponent};
+
+    store = useState(store);
+
+    setup() {
+        this.state = useState({
+            allSnapShotInstances: {},
+            pageName: "SnapShotList",
+            pageData: [],
+            pages: null,
+            currentPage: 1,
+        });
+        this.orm = useService("orm");
+
+        // Fetch all snapshot instances before the page renders.
+        onWillStart(async () => {
+            // Setting `allSnapShotInstances` of this component to the data passed in from `Dashboard` via props
+            this.state.allSnapShotInstances = store.searchedSnapshots;
+            this.state.pages = store.numberOfPages;
+        });
+
+        onWillUpdateProps((nextProps) => {
+            this.state.allSnapShotInstances = nextProps.data;
+            this.state.pages = nextProps.pages;
+        });
+    }
+
+    async viewSnapShotQuestions(snapshot) {
+        // Emit event, Dashboard will pick up and handle it
+        const orderedData = await orderCurrentSnapshotInstanceData(snapshot, {
+            orm: this.orm,
+        });
+        setTimeout(() => {
+            this.props.parentState.pageData = orderedData;
+            this.props.parentState.pageName = "SnapShotInstance";
+        }, 800);
+    }
+
+    async viewSnapshotSummary(snapshotInstance) {
+        // Prepare the data the parent component (dashboard.js) is going to need
+        this.props.parentState.pageData = await prepareAllSnapshotQuestions(
+            [snapshotInstance],
+            {orm: this.orm}
+        );
+        // Change page to 'SnapshotSummary'
+        this.props.parentState.pageName = "SnapshotSummary";
+    }
+
+    showPassOrFail(snapshot) {
+        if (snapshot.percentage_score * 100 >= 85 && snapshot.locked) {
+            return "PASS - ";
+        } else if (snapshot.percentage_score * 100 < 85 && snapshot.locked) {
+            return "FAIL - ";
+        }
+        return "";
+    }
+}
diff --git a/audit/static/src/javascript_components/dashboard/snapshot_summary.js b/audit/static/src/javascript_components/dashboard/snapshot_summary.js
new file mode 100644
index 00000000000..42e642d4457
--- /dev/null
+++ b/audit/static/src/javascript_components/dashboard/snapshot_summary.js
@@ -0,0 +1,223 @@
+/** @odoo-module **/
+import {Component, useState, onWillStart, onMounted, xml} from "@odoo/owl";
+import {useService} from "@web/core/utils/hooks";
+import {store} from "../../store";
+
+export class SnapshotSummary extends Component {
+    static template = xml`
+        <div class="snapshot-header-footer">
+            <button class="btn btn-outline-warning back-to-snapshots"
+                    t-on-click="() => this.backToAuditDashboard()">
+                <i class="fa-regular fa-circle-left" style="margin-right: 6px" />Back To Snapshots
+            </button>
+        </div>
+
+        <!-- A table to display details regarding each question in the snapshot -->
+        <div class="summary-page">
+            <t t-foreach="state.questionsWithComments"
+               t-as="entry"
+               t-key="entry.sectionName">
+                <div class="card snapshot-summary-card">
+                  <div class="card-body" style="background-color: #C7C8CC !important; border-radius: 5px !important">
+                    <h5 class="card-title summary-card-title"
+                        style="color: lightslategrey; font-weight: 700; max-width: 295px">
+                        <div t-esc="entry.sectionName" />
+                        <span class="badge section-score">
+                            Score: <t t-esc="this.calculateSectionScore(entry) + '%'" />
+                        </span>
+                    </h5>
+
+                    <!-- Card body and text contains details for each question in the snapshot-->
+                    <div class="card-text">
+                        <body class="questions-form-body summary-question-body">
+                            <table class="table table-striped table-hover table-responsive summary-table">
+                                <!--If a section has no commented questions then we don't want to display the column headers-->
+                                <t t-if="this.commentedQuestionsOnly(entry)">
+                                    <thead>
+                                        <tr>
+                                          <th scope="col">Question</th>
+                                          <th scope="col">Score</th>
+                                          <th scope="col">Comments</th>
+                                          <th scope="col">Image</th>
+                                        </tr>
+                                    </thead>
+                                </t>
+
+                                <tbody>
+                                    <tr
+                                      t-foreach="entry.questions"
+                                      t-as="question"
+                                      t-key="question.id">
+                                      <!--Only show questions that have comments-->
+                                      <t t-if="question.comment">
+                                          <td>
+                                          <div class="card-title summary-question"
+                                               data-bs-toggle="tooltip"
+                                               data-bs-placement="bottom"
+                                               data-bs-custom-class="tooltip-primary"
+                                               t-attf-title="{{ question.questionPrompt }}">
+                                               <t class="summary-question" t-esc="question.questionPrompt" />
+                                          </div>
+                                          </td>
+                                          <td style="text-align: center"><span class="question-score" t-esc="this.displayQuestionScore(question)" /></td>
+                                          <td>
+                                               <div class="summary-question" t-esc="question.comment" />
+                                          </td>
+                                          <td style="text-align: left">
+                                              <!--If there is an image display a thumbnail of it, else display a default icon-->
+                                              <t t-if="question.image">
+                                                  <img t-attf-id="{{ question.id }}"
+                                                       class="summary-image-thumbnail"
+                                                       t-on-click="() => this.resizeImage(question.id)"
+                                                       src="" />
+                                              </t>
+                                              <t t-else="">
+                                                  <i class="fa-regular fa-image" />
+                                              </t>
+                                          </td>
+                                      </t>
+                                    </tr>
+                                </tbody>
+
+                            </table>
+                        </body>
+                    </div>
+                  </div>
+                </div>
+            </t>
+
+            <!--Finally display the snapshot score-->
+            <div class="card snapshot-final-score-footer">
+              <div class="card-body" style="max-height: 45px; background-color: #0C2D57 !important; border-radius: 5px !important;">
+                <h5 class="card-title summary-card-title" style="color: lightslategrey; font-weight: 500">
+                    Snapshot Score
+                    <span class="badge final-snapshot-score">
+                        <t t-esc="state.snapshotScore.toFixed(2) + '%'" />
+                    </span>
+                </h5>
+              </div>
+            </div>
+        </div>
+    `;
+
+    static props = {
+        data: {},
+        parentState: "", // ParentState is the parents (dashboard.js) state, received here by the child component
+    };
+
+    setup() {
+        this.store = useState(store);
+        this.orm = useService("orm");
+
+        this.state = useState({
+            pageName: "SnapshotSummary",
+            pageData: [],
+            questionsWithComments: [],
+            snapshotScore: 0,
+        });
+
+        onWillStart(() => {
+            this.state.snapshotScore = this.props.data[0].percentage_score * 100;
+            this.state.pageData = this.props.data;
+            // Extract only what is needed
+            this.getQuestions(this.state.pageData);
+        });
+
+        // Find html elements that should have images, convert those images and then display them
+        onMounted(() => {
+            this.state.questionsWithComments.forEach((entry) => {
+                if (entry.questions) {
+                    entry.questions.forEach((question) => {
+                        this.convertBase64ToFile(question);
+                    });
+                }
+            });
+        });
+    }
+
+    getQuestions(data) {
+        let id = 0;
+        for (const [, value] of Object.entries(data[0].questions)) {
+            const questions = [];
+            const sectionQuestions = value;
+            // Skip sections with no questions (handles empty arrays on subsequent calls)
+            if (!sectionQuestions || sectionQuestions.length === 0) {
+                continue;
+            }
+
+            // A set of `sectionQuestions` will obviously all have the same section, get the section Name from the first entry
+            const sectionName = sectionQuestions[0].snapshot_section_id[1];
+            sectionQuestions.forEach((question) => {
+                questions.push({
+                    id: id++,
+                    sectionName: question.snapshot_section_id[1],
+                    questionPrompt: question.prompt,
+                    value: question.value,
+                    comment: question.comment,
+                    image: question.image ? question.image : null,
+                });
+            });
+            this.state.questionsWithComments.push({
+                sectionName: sectionName,
+                questions: questions,
+            });
+        }
+    }
+
+    convertBase64ToFile(question) {
+        // Find the right question
+        let questionElement = {};
+        for (const entry of this.state.questionsWithComments) {
+            if (entry.questions) {
+                for (const value of entry.questions) {
+                    if (value.id === question.id) {
+                        questionElement = value;
+                    }
+                }
+            }
+        }
+        const uploadedImage = document.getElementById(questionElement.id);
+        if (uploadedImage) {
+            uploadedImage.src = `data:image/png;base64, ${question.image}`;
+        }
+    }
+
+    calculateSectionScore(entry) {
+        let totalWeight = 0;
+        let totalValue = 0;
+        entry.questions.forEach((question) => {
+            totalWeight += 1;
+            totalValue += question.value;
+        });
+        return ((totalValue / totalWeight) * 100).toFixed(2);
+    }
+
+    commentedQuestionsOnly(entry) {
+        let result = 0;
+        entry.questions.forEach((question) => {
+            if (question.comment) {
+                result++;
+            }
+        });
+        // `True` will be returned if result > 0
+        return result > 0;
+    }
+
+    async backToAuditDashboard() {
+        await this.store.executeSearch(this, {force: true});
+        this.props.parentState.pageName = "auditHomePage";
+    }
+
+    displayQuestionScore(question) {
+        return `${question.value * 100}%`;
+    }
+
+    resizeImage(questionID) {
+        const image = document.getElementById(questionID);
+        if (image.style.width === "200px" && image.style.height === "200px") {
+            image.style = "width: 50px; height: 50px";
+        } else {
+            image.style = "width: 200px; height: 200px";
+        }
+    }
+}
diff --git a/audit/static/src/store.js b/audit/static/src/store.js
new file mode 100644
index 00000000000..fa2ff1bed18
--- /dev/null
+++ b/audit/static/src/store.js
@@ -0,0 +1,80 @@
+/** @odoo-module **/
+import {reactive} from "@odoo/owl";
+
+/**
+ * This allows central storage of state
+ */
+class Store {
+    // These fields are for the search capability
+    searchText = null;
+    searchDate = null;
+    searchStatus = null;
+    searchPage = 1;
+
+    // This will get returned always by the search query
+    numberOfPages = 1;
+    searchedSnapshots = [];
+
+    /**
+     * Page numbers (and "..." entries) for pagination, derived from numberOfPages and searchPage.
+     */
+    get visiblePages() {
+        const total = this.numberOfPages;
+        const current = this.searchPage;
+        if (total < 1) {
+            return [];
+        }
+        if (total === 1) {
+            return [1];
+        }
+        if (total <= 7) {
+            return Array.from({length: total}, (_, i) => i + 1);
+        }
+        if (current <= 4) {
+            return [1, 2, 3, 4, 5, "...", total];
+        }
+        if (current >= total - 3) {
+            return [1, "...", total - 4, total - 3, total - 2, total - 1, total];
+        }
+        return [1, "...", current - 1, current, current + 1, "...", total];
+    }
+
+    /**
+     * This will return the string that we send to the search endpoint
+     */
+    get searchString() {
+        return JSON.stringify({
+            searchText: this.searchText,
+            searchDate: this.searchDate,
+            searchStatus: this.searchStatus,
+            searchPage: this.searchPage,
+        });
+    }
+    /**
+     * Revert back to defaults
+     */
+    resetSearchFields() {
+        this.searchText = null;
+        this.searchDate = null;
+        this.searchStatus = null;
+        this.searchPage = 1;
+    }
+    /**
+     * This will submit the search to the backend, and update the relevant data
+     */
+    async executeSearch(api) {
+        const results = await api.orm.call("audit.snapshot", "custom_search", [
+            this.searchString,
+        ]);
+        this.numberOfPages = results.numberOfPages;
+        const returnedPage = results.newPageNumber;
+        this.searchPage =
+            returnedPage !== null && returnedPage !== undefined && returnedPage > 0
+                ? returnedPage
+                : 1;
+        this.searchedSnapshots = results.snapshots;
+    }
+}
+
+// Make this available to all components and reactive
+export const store = reactive(new Store());
diff --git a/audit/tests/__init__.py b/audit/tests/__init__.py
new file mode 100644
index 00000000000..68db8ecfa3c
--- /dev/null
+++ b/audit/tests/__init__.py
@@ -0,0 +1,10 @@
+# pylint: disable=missing-module-docstring
+
+from . import test_audit_question
+from . import test_audit_section
+from . import test_audit_domain
+from . import test_audit_target
+from . import test_audit_team
+from . import test_audit_inspector
+from . import test_audit_access_control
+from . import test_audit_snapshot
diff --git a/audit/tests/test_audit_access_control.py b/audit/tests/test_audit_access_control.py
new file mode 100644
index 00000000000..b96427887e5
--- /dev/null
+++ b/audit/tests/test_audit_access_control.py
@@ -0,0 +1,263 @@
+"""Tests for audit menu access (TransientModel) actions."""
+
+import uuid
+
+from odoo import Command
+from odoo.tests import tagged
+from odoo.tests.common import TransactionCase
+
+
+@tagged("audit_models", "audit_model_access_control")
+class TestAuditMenuAccessControl(TransactionCase):
+    """Tests for `audit.menu.access.control` (wizards/audit_menu_access_control)."""
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.Access = cls.env["audit.menu.access.control"]
+        cls.admin_user = cls.env.ref("base.user_admin")
+        cls.inspector = cls.env["audit.inspector"].create({"name": "IC Access"})
+
+    def _internal_user(self):
+        """Return a non-admin user (``res.users`` create rules differ by edition)."""
+        template = self.env.ref("base.default_user", raise_if_not_found=False)
+        if not template:
+            self.skipTest(
+                "base.default_user template is not available in this database"
+            )
+        suffix = uuid.uuid4().hex
+        return template.sudo().copy(
+            {
+                "name": f"Audit access test {suffix}",
+                "login": f"audit_access_{suffix}@test.local",
+                "password": "audit-access-test",
+            }
+        )
+
+    def test_check_user_access_admin(self):
+        user, allowed = self.Access.with_user(self.admin_user).check_user_access()
+        self.assertTrue(allowed)
+        self.assertEqual(user, self.admin_user)
+
+    def test_check_user_access_unknown_user_denied(self):
+        bogus_id = self.env["res.users"].search([], order="id desc", limit=1).id + 9
+        internal = self._internal_user()
+        user, allowed = self.Access.with_user(internal).check_user_access(
+            user_id=bogus_id
+        )
+        self.assertFalse(allowed)
+        self.assertIsNone(user)
+
+    def test_get_team_member_ids_includes_members_and_leaders(self):
+        inspector_1 = self.env["audit.inspector"].create({"name": "Inspector_Gadget"})
+        inspector_2 = self.env["audit.inspector"].create({"name": "Inspector_Wallace"})
+        team_leader = self.env["audit.inspector"].create({"name": "Team_Leader"})
+
+        # Create the team
+        team = self.env["audit.team"].create(
+            {
+                "name": "Access Team",
+                "team_member_ids": [Command.set((inspector_1 | inspector_2).ids)],
+                "team_leader_ids": [Command.set(team_leader.ids)],
+            }
+        )
+
+        # Check the team leader is in fact the team leader
+        self.assertIn(team_leader.id, [team.team_leader_ids.id])
+        # Check the team members are in fact inspectors 1 & 2
+        self.assertEqual(
+            [inspector_1.id, inspector_2.id],
+            [member.id for member in team.team_member_ids],
+        )
+
+    def test_build_standard_action_denied_returns_notification(self):
+        bogus_id = self.env["res.users"].search([], order="id desc", limit=1).id + 99999
+        internal = self._internal_user()
+        action = self.Access.with_user(internal)._build_standard_action(
+            user_id=bogus_id,
+            name="X",
+            res_model="audit.team",
+            domain_type="team",
+        )
+        self.assertEqual(action.get("type"), "ir.actions.client")
+        self.assertEqual(action.get("tag"), "display_notification")
+
+    def test_inspectors_menu_action_admin_returns_window_action(self):
+        action = self.Access.with_user(self.admin_user).inspectors_menu_action()
+        self.assertEqual(action.get("type"), "ir.actions.act_window")
+        self.assertEqual(action.get("res_model"), "audit.inspector")
+
+    def test_check_user_access_non_admin_finds_by_user_id(self):
+        internal = self._internal_user()
+        user, allowed = self.Access.with_user(internal).check_user_access(
+            user_id=internal.id
+        )
+        self.assertTrue(allowed)
+        self.assertEqual(user, internal)
+
+    def test_get_team_member_ids_for_leader_aggregates_members(self):
+        inspector_1 = self.env["audit.inspector"].create(
+            {"name": "G_Member_A"},
+        )
+        inspector_2 = self.env["audit.inspector"].create(
+            {"name": "G_Member_B"},
+        )
+        team_leader = self.env["audit.inspector"].create(
+            {"name": "G_Team_Leader"},
+        )
+        self.env["audit.team"].create(
+            {
+                "name": "G Team M IDs",
+                "team_member_ids": [Command.set((inspector_1 | inspector_2).ids)],
+                "team_leader_ids": [Command.set(team_leader.ids)],
+            }
+        )
+        result = set(self.Access._get_team_member_ids(team_leader))
+        for ins in (inspector_1, inspector_2, team_leader):
+            self.assertIn(ins.id, result)
+
+    def test_get_team_member_ids_not_leader_no_team_returns_empty(self):
+        only_member = self.env["audit.inspector"].create(
+            {"name": "G_Lonely_Inspector"},
+        )
+        self.assertEqual(self.Access._get_team_member_ids(only_member), [])
+
+    def test_get_inspector_based_domain_for_admin(self):
+        self.assertEqual(
+            self.Access._get_inspector_based_domain(self.admin_user, "inspector_id"),
+            [],
+        )
+
+    def test_get_inspector_based_domain_no_inspector(self):
+        internal = self._internal_user()
+        self.assertEqual(
+            self.Access._get_inspector_based_domain(internal, "inspector_id"),
+            [("id", "=", False)],
+        )
+
+    def test_get_inspector_based_domain_solo_inspector(self):
+        internal = self._internal_user()
+        u_ins = self.env["audit.inspector"].create(
+            {
+                "name": "G Access Insp",
+                "res_user_id": internal.id,
+            }
+        )
+        self.assertEqual(
+            self.Access._get_inspector_based_domain(internal, "inspector_id"),
+            [("inspector_id", "=", u_ins.id)],
+        )
+
+    def test_get_inspector_based_domain_team_leader_uses_in_domain(self):
+        leader_user = self._internal_user()
+        other_user = self._internal_user()
+        m1 = self.env["audit.inspector"].create(
+            {
+                "name": "G_LI_1",
+                "res_user_id": leader_user.id,
+            }
+        )
+        m2 = self.env["audit.inspector"].create(
+            {
+                "name": "G_LI_2",
+                "res_user_id": other_user.id,
+            }
+        )
+        self.env["audit.team"].create(
+            {
+                "name": "G Lead In Dom",
+                "team_member_ids": [Command.set([m2.id])],
+                "team_leader_ids": [Command.set([m1.id])],
+            }
+        )
+        dom = self.Access._get_inspector_based_domain(leader_user, "inspector_id")
+        self.assertEqual(dom[0][:2], ("inspector_id", "in"))
+        in_ids = dom[0][2]
+        self.assertIn(m1.id, in_ids)
+        self.assertIn(m2.id, in_ids)
+
+    def test_get_team_leadership_domain_variants(self):
+        self.assertEqual(
+            self.Access._get_team_leadership_domain(self.admin_user),
+            [],
+        )
+        internal = self._internal_user()
+        self.assertEqual(
+            self.Access._get_team_leadership_domain(internal),
+            [("id", "=", False)],
+        )
+        leader = self._internal_user()
+        lead_ins = self.env["audit.inspector"].create(
+            {
+                "name": "G_Team_dom",
+                "res_user_id": leader.id,
+            }
+        )
+        self.env["audit.team"].create(
+            {
+                "name": "G TLDom",
+                "team_leader_ids": [Command.set([lead_ins.id])],
+            }
+        )
+        tdom = self.Access._get_team_leadership_domain(leader)
+        self.assertEqual(
+            tdom,
+            [("team_leader_ids", "in", [lead_ins.id])],
+        )
+        not_leader = self._internal_user()
+        nli = self.env["audit.inspector"].create(
+            {
+                "name": "G_Not_Lead",
+                "res_user_id": not_leader.id,
+            }
+        )
+        self.env["audit.team"].create(
+            {
+                "name": "G TLDom member",
+                "team_member_ids": [Command.set([nli.id])],
+            }
+        )
+        self.assertEqual(
+            self.Access._get_team_leadership_domain(not_leader),
+            [("id", "=", False)],
+        )
+
+    def test_build_standard_action_allows_with_context(self):
+        action = self.Access.with_user(
+            self.admin_user,
+        )._build_standard_action(
+            user_id=self.admin_user.id,
+            name="Ctx",
+            res_model="audit.snapshot",
+            domain_type="inspector",
+            domain_field="inspector_id",
+            context={"a": 1},
+        )
+        self.assertEqual(action.get("type"), "ir.actions.act_window")
+        self.assertEqual(action.get("context"), {"a": 1})
+
+    def test_menu_action_helpers_return_window_for_admin(self):
+        admin = self.admin_user
+        cases = [
+            (lambda: self.Access.with_user(admin).teams_menu_action(), "audit.team"),
+            (
+                lambda: self.Access.with_user(admin).snapshots_menu_action(),
+                "audit.snapshot",
+            ),
+            (
+                lambda: self.Access.with_user(admin).archived_snapshots_menu_action(),
+                "audit.snapshot",
+            ),
+            (
+                lambda: self.Access.with_user(admin).snapshot_sections_menu_action(),
+                "audit.snapshot_section",
+            ),
+            (
+                lambda: self.Access.with_user(admin).snapshot_questions_menu_action(),
+                "audit.snapshot_question",
+            ),
+        ]
+        for call, model in cases:
+            a = call()
+            self.assertEqual(a.get("type"), "ir.actions.act_window", msg=repr(a))
+            self.assertEqual(a.get("res_model"), model)
diff --git a/audit/tests/test_audit_domain.py b/audit/tests/test_audit_domain.py
new file mode 100644
index 00000000000..725088a8439
--- /dev/null
+++ b/audit/tests/test_audit_domain.py
@@ -0,0 +1,86 @@
+"""Tests for `audit.domain` and domain duplication."""
+
+import uuid
+
+import psycopg2.errors
+
+from odoo.exceptions import ValidationError
+from odoo.tests import tagged
+from odoo.tests.common import TransactionCase
+from odoo.tools import mute_logger
+
+
+@tagged("audit_models", "audit_model_domain")
+class TestAuditDomain(TransactionCase):
+    """Tests for ``audit.domain`` (``models/audit_domain.py``)."""
+
+    def test_domain_name_unique(self):
+        name = f"Unique Domain {uuid.uuid4().hex}"
+        self.env["audit.domain"].create({"name": name})
+        with mute_logger("odoo.sql_db"):
+            try:
+                self.env["audit.domain"].create({"name": name})
+            except (ValidationError, psycopg2.errors.UniqueViolation):
+                return
+        self.fail("expected duplicate domain name to be rejected")
+
+    def test_compute_all_target_rel_ids_merges_one2many_and_many2many(self):
+        domain = self.env["audit.domain"].create({"name": "Merge Targets Domain"})
+        t_primary = self.env["audit.target"].create(
+            {"name": "Primary target", "domain_id": domain.id}
+        )
+        t_extra = self.env["audit.target"].create({"name": "Extra target"})
+        domain.target_rel_ids = [(6, 0, [t_extra.id])]
+        domain.invalidate_recordset()
+        self.assertIn(t_primary, domain.all_target_rel_ids)
+        self.assertIn(t_extra, domain.all_target_rel_ids)
+
+    def test_action_duplicate_domain_creates_copy_with_sections_and_questions(self):
+        domain = self.env["audit.domain"].create({"name": "Original Domain For Dup"})
+        section = self.env["audit.section"].create(
+            {"name": "Sec", "domain_id": domain.id}
+        )
+        self.env["audit.question"].create(
+            {
+                "prompt": "Dup Q",
+                "answer_type": "integer",
+                "section_id": section.id,
+            }
+        )
+        action = domain.action_duplicate_domain()
+        self.assertEqual(action.get("type"), "ir.actions.client")
+        new_domains = self.env["audit.domain"].search(
+            [("name", "ilike", "Original Domain For Dup - Duplicate_")]
+        )
+        self.assertEqual(len(new_domains), 1)
+        self.assertTrue(new_domains.section_ids)
+        self.assertTrue(new_domains.section_ids.question_ids)
+
+    def test_action_duplicate_domain_links_each_target_id(self):
+        domain = self.env["audit.domain"].create(
+            {"name": "Multi-target domain duplicate"},
+        )
+        self.env["audit.target"].create(
+            {
+                "name": "T multi A",
+                "domain_id": domain.id,
+            }
+        )
+        self.env["audit.target"].create(
+            {
+                "name": "T multi B",
+                "domain_id": domain.id,
+            }
+        )
+        self.env["audit.section"].create(
+            {
+                "name": "S multi",
+                "domain_id": domain.id,
+            }
+        )
+        action = domain.action_duplicate_domain()
+        self.assertEqual(action.get("type"), "ir.actions.client")
+        dup = self.env["audit.domain"].search(
+            [("name", "ilike", "Multi-target domain duplicate - Duplicate_")],
+        )
+        self.assertEqual(len(dup.target_rel_ids), 2)
diff --git a/audit/tests/test_audit_inspector.py b/audit/tests/test_audit_inspector.py
new file mode 100644
index 00000000000..d657f3fc650
--- /dev/null
+++ b/audit/tests/test_audit_inspector.py
@@ -0,0 +1,42 @@
+"""Tests for `audit.inspector`."""
+
+from odoo.tests import tagged
+from odoo.tests.common import TransactionCase
+
+
+@tagged("audit_models", "audit_model_inspector")
+class TestAuditInspector(TransactionCase):
+    """Tests for ``audit.inspector`` (``models/audit_inspector.py``)."""
+
+    def test_full_name_from_partner_name(self):
+        partner = self.env["res.partner"].create({"name": "Ada Lovelace"})
+        inspector = self.env["audit.inspector"].create(
+            {"name": "Inspector record", "partner_id": partner.id},
+        )
+        self.assertEqual(inspector.full_name, "Ada Lovelace")
+
+    def test_full_name_from_forename_surname(self):
+        inspector = self.env["audit.inspector"].create(
+            {
+                "name": "Fallback",
+                "forename": "Grace",
+                "surname": "Hopper",
+            }
+        )
+        self.assertEqual(inspector.full_name, "Grace Hopper")
+
+    def test_create_without_partner_builds_name_from_parts(self):
+        inspector = self.env["audit.inspector"].create(
+            {"forename": "Alan", "surname": "Turing"},
+        )
+        self.assertEqual(inspector.name, "Alan Turing")
+
+    def test_create_without_partner_uses_generic_when_no_parts(self):
+        inspector = self.env["audit.inspector"].create({})
+        self.assertEqual(inspector.name, "Inspector")
+
+    def test_full_name_uses_record_name_when_no_partner_or_forename(self):
+        inspector = self.env["audit.inspector"].create(
+            {"name": "Display Only Name"},
+        )
+        self.assertEqual(inspector.full_name, "Display Only Name")
diff --git a/audit/tests/test_audit_question.py b/audit/tests/test_audit_question.py
new file mode 100644
index 00000000000..4f07138bfc8
--- /dev/null
+++ b/audit/tests/test_audit_question.py
@@ -0,0 +1,40 @@
+"""Tests for `audit.question`."""
+
+import psycopg2.errors
+
+from odoo.tests import tagged
+from odoo.tests.common import TransactionCase
+from odoo.tools import mute_logger
+
+
+@tagged("audit_models", "audit_model_question")
+class TestAuditQuestion(TransactionCase):
+    """Tests for ``audit.question`` (``models/audit_question.py``)."""
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.domain = cls.env["audit.domain"].create({"name": "Question Test Domain"})
+        cls.section = cls.env["audit.section"].create(
+            {"name": "Section A", "domain_id": cls.domain.id}
+        )
+
+    def test_name_follows_prompt(self):
+        prompt = "Is the emergency exit clear?"
+        question = self.env["audit.question"].create(
+            {
+                "prompt": prompt,
+                "answer_type": "boolean",
+                "section_id": self.section.id,
+            }
+        )
+        self.assertEqual(question.name, prompt)
+
+    def test_required_answer_type(self):
+        with (
+            mute_logger("odoo.sql_db"),
+            self.assertRaises(psycopg2.errors.NotNullViolation),
+        ):
+            self.env["audit.question"].create(
+                {"prompt": "Missing type", "section_id": self.section.id}
+            )
diff --git a/audit/tests/test_audit_section.py b/audit/tests/test_audit_section.py
new file mode 100644
index 00000000000..795a80e9c49
--- /dev/null
+++ b/audit/tests/test_audit_section.py
@@ -0,0 +1,30 @@
+"""Tests for `audit.section`."""
+
+import psycopg2.errors
+
+from odoo.tests import tagged
+from odoo.tests.common import TransactionCase
+from odoo.tools import mute_logger
+
+
+@tagged("audit_models", "audit_model_section")
+class TestAuditSection(TransactionCase):
+    """Tests for ``audit.section`` (``models/audit_section.py``)."""
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.domain = cls.env["audit.domain"].create({"name": "Section Test Domain"})
+
+    def test_create_section_linked_to_domain(self):
+        section = self.env["audit.section"].create(
+            {"name": "Opening checks", "domain_id": self.domain.id}
+        )
+        self.assertEqual(section.domain_id, self.domain)
+
+    def test_domain_id_required(self):
+        with (
+            mute_logger("odoo.sql_db"),
+            self.assertRaises(psycopg2.errors.NotNullViolation),
+        ):
+            self.env["audit.section"].create({"name": "Orphan section"})
diff --git a/audit/tests/test_audit_snapshot.py b/audit/tests/test_audit_snapshot.py
new file mode 100644
index 00000000000..0ac815a63ec
--- /dev/null
+++ b/audit/tests/test_audit_snapshot.py
@@ -0,0 +1,274 @@
+"""Tests for `audit.snapshot` and related records."""
+
+import json
+import uuid
+
+from odoo.exceptions import UserError
+from odoo.tests import tagged
+from odoo.tests.common import TransactionCase
+
+
+@tagged("audit_models", "audit_model_snapshot")
+class TestAuditSnapshot(TransactionCase):
+    """Tests for snapshot models in ``models/audit_snapshot.py``."""
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.domain = cls.env["audit.domain"].create({"name": "Snapshot Domain"})
+        cls.section = cls.env["audit.section"].create(
+            {"name": "Snap Section", "domain_id": cls.domain.id}
+        )
+        cls.question = cls.env["audit.question"].create(
+            {
+                "prompt": "Is it clean?",
+                "answer_type": "boolean",
+                "section_id": cls.section.id,
+            }
+        )
+        cls.target = cls.env["audit.target"].create(
+            {"name": "Snapshot Target", "domain_id": cls.domain.id}
+        )
+        cls.inspector = cls.env["audit.inspector"].create({"name": "Snap Inspector"})
+        cls.env["audit.team"].create({"name": "Snapshot Team"})
+
+    def test_snapshot_question_compute_value_boolean_and_star(self):
+        ss = self.env["audit.snapshot_section"].create(
+            {
+                "name": "S",
+                "domain_id": self.domain.id,
+            }
+        )
+        sq = self.env["audit.snapshot_question"].create(
+            {
+                "snapshot_section_id": ss.id,
+                "answer_type": "boolean",
+                "answer_yn": "1",
+                "answer_star": "4",
+                "answer_perc": 0.0,
+            }
+        )
+        self.assertAlmostEqual(sq.value, 1.0 + 1.0 + 0.0)
+
+    def test_snapshot_question_toggle_not_applicable(self):
+        ss = self.env["audit.snapshot_section"].create(
+            {"name": "S2", "domain_id": self.domain.id}
+        )
+        sq = self.env["audit.snapshot_question"].create(
+            {
+                "snapshot_section_id": ss.id,
+                "answer_type": "boolean",
+                "applicable": True,
+            }
+        )
+        out = self.env["audit.snapshot_question"].toggle_not_applicable(sq.id)
+        self.assertFalse(out["applicable"])
+        out2 = self.env["audit.snapshot_question"].toggle_not_applicable(sq.id)
+        self.assertTrue(out2["applicable"])
+
+    def test_snapshot_section_scores(self):
+        snap = self.env["audit.snapshot"].create(
+            {
+                "domain_id": self.domain.id,
+                "target_id": self.target.id,
+                "inspector_id": self.inspector.id,
+            }
+        )
+        section = snap.snapshot_section_ids[0]
+        questions = section.snapshot_question_ids
+        self.assertTrue(questions)
+        questions.write(
+            {
+                "answer_yn": "1",
+                "answer_star": "4",
+                "answer_perc": 0.0,
+            }
+        )
+        section.invalidate_recordset()
+        self.assertGreater(section.maximum_section_score, 0)
+        self.assertGreater(section.actual_section_score, 0)
+        self.assertGreaterEqual(section.percentage_section_score, 0.0)
+
+    def test_snapshot_create_requires_domain_target_inspector(self):
+        with self.assertRaises(UserError):
+            self.env["audit.snapshot"].create(
+                {
+                    "domain_id": self.domain.id,
+                    "target_id": self.target.id,
+                }
+            )
+
+    def test_snapshot_compute_name(self):
+        snap = self.env["audit.snapshot"].create(
+            {
+                "domain_id": self.domain.id,
+                "target_id": self.target.id,
+                "inspector_id": self.inspector.id,
+            }
+        )
+        self.assertIn(self.target.name, snap.name)
+
+    def test_get_snapshot_questions_structure(self):
+        snap = self.env["audit.snapshot"].create(
+            {
+                "domain_id": self.domain.id,
+                "target_id": self.target.id,
+                "inspector_id": self.inspector.id,
+            }
+        )
+        data = snap.get_snapshot_questions()
+        self.assertIn("sections", data)
+        self.assertIn("questions", data)
+        self.assertEqual(data["all_locked"], snap.locked)
+
+    def test_custom_search_minimal_json_admin(self):
+        payload = json.dumps({"searchPage": 1})
+        result = self.env["audit.snapshot"].custom_search(payload)
+        self.assertIn("snapshots", result)
+        self.assertIn("numberOfPages", result)
+        self.assertIn("newPageNumber", result)
+
+    def test_get_snapshot_questions_on_empty_recordset(self):
+        self.assertEqual(
+            self.env["audit.snapshot"].browse([]).get_snapshot_questions(),
+            {},
+        )
+
+    def test_snapshot_create_accepts_list_vals(self):
+        snap = self.env["audit.snapshot"].create(
+            [
+                {
+                    "domain_id": self.domain.id,
+                    "target_id": self.target.id,
+                    "inspector_id": self.inspector.id,
+                }
+            ]
+        )
+        self.assertTrue(snap.id)
+
+    def test_snapshot_question_write_image_stores_base64(self):
+        ss = self.env["audit.snapshot_section"].create(
+            {"name": "ImgSec", "domain_id": self.domain.id}
+        )
+        sq = self.env["audit.snapshot_question"].create(
+            {
+                "snapshot_section_id": ss.id,
+                "answer_type": "boolean",
+            }
+        )
+        # Image field: pass raw base64; data URLs are not valid here.
+        b64 = "R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs="
+        sq.write({"image": b64})
+        self.assertTrue(bool(sq.image), msg="base64 image payload should be stored")
+
+    def test_custom_search_filters_text_status_and_clamps_page(self):
+        for _i in range(3):
+            self.env["audit.snapshot"].create(
+                {
+                    "domain_id": self.domain.id,
+                    "target_id": self.target.id,
+                    "inspector_id": self.inspector.id,
+                }
+            )
+        for snap in self.env["audit.snapshot"].search([]):
+            snap.write({"percentage_score": 0.1})
+        ptext = json.dumps(
+            {
+                "searchText": "Snapshot",
+                "searchStatus": "FAIL",
+                "searchPage": 1,
+            }
+        )
+        r1 = self.env["audit.snapshot"].custom_search(ptext)
+        self.assertIn("snapshots", r1)
+        ppass = json.dumps(
+            {
+                "searchText": "Snapshot",
+                "searchStatus": "PASS",
+                "searchPage": 1,
+            }
+        )
+        for snap in self.env["audit.snapshot"].search([]):
+            snap.write({"percentage_score": 0.9})
+        r2 = self.env["audit.snapshot"].custom_search(ppass)
+        self.assertIn("numberOfPages", r2)
+        pbig = json.dumps(
+            {
+                "searchText": "Snapshot",
+                "searchStatus": "PASS",
+                "searchPage": 9999,
+            }
+        )
+        r3 = self.env["audit.snapshot"].custom_search(pbig)
+        self.assertIsInstance(r3.get("newPageNumber"), (int, type(None)))
+
+    def test_snapshot_percentage_score_recomputes_from_dicts(self):
+        snap = self.env["audit.snapshot"].create(
+            {
+                "domain_id": self.domain.id,
+                "target_id": self.target.id,
+                "inspector_id": self.inspector.id,
+            }
+        )
+        self.env["audit.snapshot"].snapshot_percentage_score(
+            [{"id": snap.id, "name": "x"}]
+        )
+        self.assertIsNotNone(snap.percentage_score)
+
+    def test_questions_with_comments_count_when_locked(self):
+        snap = self.env["audit.snapshot"].create(
+            {
+                "domain_id": self.domain.id,
+                "target_id": self.target.id,
+                "inspector_id": self.inspector.id,
+            }
+        )
+        section = snap.snapshot_section_ids[0]
+        q = section.snapshot_question_ids[0]
+        q.write({"comment": "note"})
+        snap.locked = True
+        self.assertEqual(snap.questions_with_comments, 1)
+
+    def _internal_user(self):
+        """Build a non-admin user for with_user (same idea as access tests)."""
+        template = self.env.ref("base.default_user", raise_if_not_found=False)
+        if not template:
+            self.skipTest("base.default_user is not available in this database")
+        suffix = uuid.uuid4().hex
+        return template.sudo().copy(
+            {
+                "name": f"Snapshot su {suffix}",
+                "login": f"audit_sp_{suffix}@test.local",
+                "password": "snap-test-pass",
+            }
+        )
+
+    def test_snapshots_per_user_non_admin_inspector(self):
+        user = self._internal_user()
+        self.env["audit.inspector"].create(
+            {
+                "name": "Sp User Insp",
+                "res_user_id": user.id,
+            }
+        )
+        self.env["audit.snapshot"].create(
+            {
+                "domain_id": self.domain.id,
+                "target_id": self.target.id,
+                "inspector_id": self.inspector.id,
+            }
+        )
+        rows, total = (
+            self.env["audit.snapshot"]
+            .with_user(
+                user,
+            )
+            .snapshots_per_user(
+                [("active", "=", True)],
+                1,
+            )
+        )
+        self.assertIsInstance(rows, list)
+        self.assertIsInstance(total, int)
+        self.assertGreaterEqual(total, 0)
+        self.assertGreaterEqual(len(rows), 0)
diff --git a/audit/tests/test_audit_target.py b/audit/tests/test_audit_target.py
new file mode 100644
index 00000000000..27f59dd9b46
--- /dev/null
+++ b/audit/tests/test_audit_target.py
@@ -0,0 +1,132 @@
+"""Tests for `audit.target`."""
+
+import uuid
+
+from odoo.exceptions import ValidationError
+from odoo.tests import tagged
+from odoo.tests.common import TransactionCase
+
+
+@tagged("audit_models", "audit_model_target")
+class TestAuditTarget(TransactionCase):
+    """Tests for `audit.target` and `audit.domain_target_rel`."""
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.domain = cls.env["audit.domain"].create({"name": "Target Test Domain"})
+
+    def test_duplicate_target_name_rejected_on_create(self):
+        self.env["audit.target"].create(
+            {"name": "Same Name Store", "domain_id": self.domain.id}
+        )
+        with self.assertRaises(ValidationError):
+            self.env["audit.target"].create(
+                {"name": "Same Name Store", "domain_id": self.domain.id}
+            )
+
+    def test_create_sets_domain_id_from_all_domain_rel_ids(self):
+        other = self.env["audit.domain"].create({"name": "Secondary Domain"})
+        target = self.env["audit.target"].create(
+            {
+                "name": "Target with rel domains",
+                "all_domain_rel_ids": [(6, 0, [other.id])],
+            }
+        )
+        self.assertEqual(target.domain_id, other)
+
+    def test_link_to_domain_creates_relation_once(self):
+        target = self.env["audit.target"].create(
+            {"name": "Linkable", "domain_id": self.domain.id}
+        )
+        target.link_to_domain(self.domain.id, target.id)
+        rel = self.env["audit.domain_target_rel"].search(
+            [
+                ("domain_id", "=", self.domain.id),
+                ("target_id", "=", target.id),
+            ]
+        )
+        self.assertTrue(rel)
+        target.link_to_domain(self.domain.id, target.id)
+        self.assertEqual(
+            len(
+                self.env["audit.domain_target_rel"].search(
+                    [
+                        ("domain_id", "=", self.domain.id),
+                        ("target_id", "=", target.id),
+                    ]
+                )
+            ),
+            1,
+        )
+
+    def test_write_rejects_duplicate_name(self):
+        self.env["audit.target"].create({"name": "Alpha", "domain_id": self.domain.id})
+        beta = self.env["audit.target"].create(
+            {"name": "Beta", "domain_id": self.domain.id}
+        )
+        with self.assertRaises(ValidationError):
+            beta.write({"name": "Alpha"})
+
+    def test_write_sets_domain_id_from_all_domain_rel_ids(self):
+        other = self.env["audit.domain"].create(
+            {"name": f"Write Domain {uuid.uuid4().hex[:8]}"},
+        )
+        target = self.env["audit.target"].create(
+            {"name": f"T no primary {uuid.uuid4().hex[:6]}"}
+        )
+        self.assertFalse(target.domain_id)
+        target.write(
+            {
+                "all_domain_rel_ids": [
+                    (6, 0, [other.id]),
+                ],
+            }
+        )
+        self.assertEqual(target.domain_id, other)
+
+    def test_merge_merges_same_name_datasets(self):
+        tag = uuid.uuid4().hex[:6]
+        keep = self.env["audit.target"].create(
+            {
+                "name": f"MergeN_{tag}_keep",
+                "domain_id": self.domain.id,
+            }
+        )
+        drop = self.env["audit.target"].create(
+            {
+                "name": f"Drop_{tag}_before_merge",
+                "domain_id": self.domain.id,
+            }
+        )
+        # Force same display name as `keep` to exercise merge() deduplication.
+        self.env.cr.execute(
+            "UPDATE audit_target SET name = %s WHERE id = %s",
+            (keep.name, drop.id),
+        )
+        drop.invalidate_recordset(["name"])
+        section = self.env["audit.section"].create(
+            {
+                "name": "Msec",
+                "domain_id": self.domain.id,
+            }
+        )
+        self.env["audit.question"].create(
+            {
+                "prompt": "Mq",
+                "answer_type": "boolean",
+                "section_id": section.id,
+            }
+        )
+        inspector = self.env["audit.inspector"].create({"name": f"Insp {tag}"})
+        snap = self.env["audit.snapshot"].create(
+            {
+                "domain_id": self.domain.id,
+                "target_id": drop.id,
+                "inspector_id": inspector.id,
+            }
+        )
+        keep.merge()
+        self.assertFalse(drop.exists())
+        self.assertEqual(snap.target_id, keep)
+        self.assertFalse(keep.domain_id)
diff --git a/audit/tests/test_audit_team.py b/audit/tests/test_audit_team.py
new file mode 100644
index 00000000000..5193056857d
--- /dev/null
+++ b/audit/tests/test_audit_team.py
@@ -0,0 +1,42 @@
+"""Tests for `audit.team`."""
+
+import uuid
+
+import psycopg2.errors
+
+from odoo.exceptions import ValidationError
+from odoo.tests import tagged
+from odoo.tests.common import TransactionCase
+from odoo.tools import mute_logger
+
+
+@tagged("audit_models", "audit_model_team")
+class TestAuditTeam(TransactionCase):
+    """Tests for ``audit.team`` (``models/audit_team.py``)."""
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.inspector_a = cls.env["audit.inspector"].create({"name": "Member A"})
+        cls.inspector_b = cls.env["audit.inspector"].create({"name": "Leader B"})
+
+    def test_team_name_must_be_unique(self):
+        name = f"North Island {uuid.uuid4().hex}"
+        self.env["audit.team"].create({"name": name})
+        with mute_logger("odoo.sql_db"):
+            try:
+                self.env["audit.team"].create({"name": name})
+            except (ValidationError, psycopg2.errors.UniqueViolation):
+                return
+        self.fail("expected duplicate team name to be rejected")
+
+    def test_members_and_leaders_many2many(self):
+        team = self.env["audit.team"].create(
+            {
+                "name": "Field Team 1",
+                "team_member_ids": [(6, 0, [self.inspector_a.id])],
+                "team_leader_ids": [(6, 0, [self.inspector_b.id])],
+            }
+        )
+        self.assertIn(self.inspector_a, team.team_member_ids)
+        self.assertIn(self.inspector_b, team.team_leader_ids)
diff --git a/audit/views/actions.xml b/audit/views/actions.xml
new file mode 100644
index 00000000000..dbf9d6db083
--- /dev/null
+++ b/audit/views/actions.xml
@@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<odoo>
+    <!-- The Dashboard is where we start -->
+    <record model="ir.actions.client" id="dashboard_action">
+        <field name="name">Dashboard</field>
+        <field name="tag">audit.dashboard</field>
+    </record>
+
+    <!-- Auditable Items are the things we can audit -->
+    <record model="ir.actions.act_window" id="design_action">
+        <field name="name">Audit Design</field>
+        <field name="res_model">audit.domain</field>
+        <field name="view_mode">list,form</field>
+    </record>
+
+    <!-- Conducting audits creates Snapshot instances-->
+    <record model="ir.actions.act_window" id="create_snapshot_action">
+        <field name="name">Conduct Audits</field>
+        <field name="res_model">audit.snapshot</field>
+        <field name="view_mode">list,form</field>
+    </record>
+
+    <!-- Action to view Snapshot Questions-->
+    <record id="action_snapshot_questions_view" model="ir.actions.client">
+        <field name="name">Snapshot Questions</field>
+        <field name="tag">audit.snapshot_questions_view</field>
+    </record>
+
+    <!--Action when user clicks on 'Back To Snapshots' so that Snapshot List View is called-->
+    <record id="action_audit_snapshots_list" model="ir.actions.act_window">
+        <field name="name">Audit Snapshots</field>
+        <field name="res_model">audit.snapshot</field>
+        <field name="view_mode">list,form</field>
+        <field name="target">current</field>
+    </record>
+
+    <!-- Server Actions with Access Control Logic, passing logged-in user ID -->
+    <!-- Must have ref="audit.model_audit_menu_access_control", for anything else a different set of rules-->
+    <!-- will be called before the custom rules inside each action can be called-->
+    <record id="teams_menu_action" model="ir.actions.server">
+        <field name="name">teams_menu_action (with Access Control)</field>
+        <field name="model_id" ref="audit.model_audit_menu_access_control" />
+        <field name="state">code</field>
+        <field name="code">action = model.teams_menu_action(user_id=env.uid)</field>
+    </record>
+
+    <!-- Inspectors menu action -->
+    <record id="inspectors_menu_action" model="ir.actions.server">
+        <field name="name">inspectors_menu_action (with Access Control)</field>
+        <field name="model_id" ref="audit.model_audit_menu_access_control" />
+        <field name="state">code</field>
+        <field
+            name="code"
+        >action = model.inspectors_menu_action(user_id=env.uid)</field>
+    </record>
+
+    <!-- Snapshot menu action -->
+    <record id="snapshots_menu_action" model="ir.actions.server">
+        <field name="name">snapshots_menu_action (with Access Control)</field>
+        <field name="model_id" ref="audit.model_audit_menu_access_control" />
+        <field name="state">code</field>
+        <field name="code">action = model.snapshots_menu_action(user_id=env.uid)</field>
+    </record>
+
+    <!-- Snapshot Sections menu action -->
+    <record id="snapshot_sections_menu_action" model="ir.actions.server">
+        <field name="name">snapshot_sections_menu_action (with Access Control)</field>
+        <field name="model_id" ref="audit.model_audit_menu_access_control" />
+        <field name="state">code</field>
+        <field
+            name="code"
+        >action = model.snapshot_sections_menu_action(user_id=env.uid)</field>
+    </record>
+
+    <!-- Archived Snapshots menu action -->
+    <record id="archived_snapshots_menu_action" model="ir.actions.server">
+        <field name="name">archived_snapshots_menu_action (with Access Control)</field>
+        <field name="model_id" ref="audit.model_audit_menu_access_control" />
+        <field name="state">code</field>
+        <field
+            name="code"
+        >action = model.archived_snapshots_menu_action(user_id=env.uid)</field>
+    </record>
+
+    <!-- Snapshot Questions menu action -->
+    <record id="snapshot_questions_menu_action" model="ir.actions.server">
+        <field name="name">snapshot_questions_menu_action (with Access Control)</field>
+        <field name="model_id" ref="audit.model_audit_menu_access_control" />
+        <field name="state">code</field>
+        <field
+            name="code"
+        >action = model.snapshot_questions_menu_action(user_id=env.uid)</field>
+    </record>
+
+    <!-- audit.target action -->
+    <record id="target_action" model="ir.actions.act_window">
+        <field name="name">Audit Targets</field>
+        <field name="res_model">audit.target</field>
+        <field name="view_mode">list,form</field>
+        <field name="view_id" ref="target_tree_view" />
+    </record>
+</odoo>
diff --git a/audit/views/menus.xml b/audit/views/menus.xml
new file mode 100644
index 00000000000..9744ef527f1
--- /dev/null
+++ b/audit/views/menus.xml
@@ -0,0 +1,111 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<odoo>
+    <!--  Unchanged top-level entry  -->
+    <menuitem
+        name="Audit Dashboard"
+        id="audit.menu"
+        action="dashboard_action"
+        groups="audit.group_audit_permission"
+        web_icon="audit,static/description/icon.png"
+    />
+    <!-- ===============================================================
+         TEAM MANAGEMENT
+    =============================================================== -->
+    <menuitem
+        id="audit.team_management"
+        name="Team Management"
+        parent="audit.menu"
+        sequence="10"
+        groups="audit.group_audit_permission"
+    />
+    <!-- Teams list (create / link members), Action with access control -->
+    <menuitem
+        id="audit.menu_teams"
+        name="Teams"
+        parent="audit.team_management"
+        action="teams_menu_action"
+        sequence="5"
+        groups="audit.group_audit_permission"
+    />
+    <!-- Inspectors, Action with access control -->
+    <menuitem
+        id="audit.menu_inspectors"
+        name="Inspectors"
+        parent="audit.team_management"
+        action="inspectors_menu_action"
+        sequence="10"
+        groups="audit.group_audit_permission"
+    />
+    <!-- ===============================================================
+         AUDIT DESIGN
+    =============================================================== -->
+    <menuitem
+        id="audit.audit_design"
+        name="Audit Design"
+        parent="audit.menu"
+        sequence="20"
+        groups="audit.group_audit_permission"
+    />
+    <menuitem
+        id="audit.menu_design"
+        name="Audits"
+        action="design_action"
+        parent="audit.audit_design"
+        sequence="10"
+        groups="audit.group_audit_permission"
+    />
+    <menuitem
+        id="audit.menu_target"
+        name="Audit Targets"
+        action="target_action"
+        parent="audit.audit_design"
+        sequence="20"
+        groups="audit.group_audit_permission"
+    />
+    <!-- ===============================================================
+         SNAPSHOT HISTORY
+    =============================================================== -->
+    <menuitem
+        id="audit.menu_configuration"
+        name="Snapshot History"
+        parent="audit.menu"
+        sequence="30"
+        groups="audit.group_audit_permission"
+    />
+    <!-- Action with access control -->
+    <menuitem
+        id="audit.menu_configuration_snapshots"
+        name="Snapshots"
+        parent="audit.menu_configuration"
+        action="snapshots_menu_action"
+        sequence="10"
+        groups="audit.group_audit_permission"
+    />
+    <!-- Action with access control -->
+    <menuitem
+        id="audit.menu_configuration_snapshot_sections"
+        name="Snapshot Sections"
+        parent="audit.menu_configuration"
+        action="snapshot_sections_menu_action"
+        sequence="20"
+        groups="audit.group_audit_permission"
+    />
+    <!-- Action with access control -->
+    <menuitem
+        id="audit.menu_configuration_archive_snapshot"
+        name="Archived Snapshots"
+        parent="audit.menu_configuration"
+        action="archived_snapshots_menu_action"
+        sequence="30"
+        groups="audit.group_audit_permission"
+    />
+    <!-- Action with access control -->
+    <menuitem
+        id="audit.menu_configuration_snapshot_questions"
+        name="Snapshot Questions"
+        parent="audit.menu_configuration"
+        action="snapshot_questions_menu_action"
+        sequence="40"
+        groups="audit.group_audit_permission"
+    />
+</odoo>
diff --git a/audit/views/views.xml b/audit/views/views.xml
new file mode 100644
index 00000000000..d54f614074d
--- /dev/null
+++ b/audit/views/views.xml
@@ -0,0 +1,409 @@
+<odoo>
+    <!-- audit.domain list view -->
+    <record model="ir.ui.view" id="view_domain_tree">
+        <field name="name">Audit Domains</field>
+        <field name="model">audit.domain</field>
+        <field name="arch" type="xml">
+            <list>
+                <field name="name" string="Domains" />
+            </list>
+        </field>
+    </record>
+
+    <!-- Audit domain form view-->
+    <record model="ir.ui.view" id="view_domain_form">
+        <field name="name">Audit Domains</field>
+        <field name="model">audit.domain</field>
+        <field name="type">form</field>
+        <field name="arch" type="xml">
+            <form>
+                <header>
+                    <button
+                        name="action_duplicate_domain"
+                        type="object"
+                        string="Duplicate"
+                        invisible="not id"
+                        class="oe_highlight"
+                    />
+                </header>
+                <sheet>
+                    <notebook>
+                        <page name="Domain Design">
+                            <group>
+                                <field name="name" string="Domain Name" />
+                            </group>
+                            <field name="section_ids" />
+                        </page>
+                        <page name="Targets in Domain">
+                            <field name="all_target_rel_ids" />
+                        </page>
+                    </notebook>
+                </sheet>
+            </form>
+        </field>
+    </record>
+
+    <!-- audit.inspector list view -->
+    <record id="view_inspector_tree" model="ir.ui.view">
+        <field name="name">audit.inspector.tree</field>
+        <field name="model">audit.inspector</field>
+        <field name="arch" type="xml">
+            <list>
+                <field name="name" />
+                <field name="forename" />
+                <field name="surname" />
+                <field name="inspector_email" />
+                <field name="active" />
+            </list>
+        </field>
+    </record>
+
+    <!-- audit.inspector form view-->
+    <record id="view_inspector_form" model="ir.ui.view">
+        <field name="name">audit.inspector.form</field>
+        <field name="model">audit.inspector</field>
+        <field name="arch" type="xml">
+            <form string="Inspector">
+                <!-- Boxed layout for identity fields -->
+                <div
+                    class="o_group o_inner_group card p-3 mb-4"
+                    style="margin-bottom: 80px !important; max-width: 600px;"
+                >
+                    <group>
+                        <field name="res_user_id" />
+                        <field name="forename" widget="text" />
+                        <field name="surname" widget="text" />
+                        <field name="inspector_email" widget="email" />
+                    </group>
+                </div>
+                <!-- Other inspector-related fields -->
+                <group>
+                    <field name="snapshot_ids" />
+                    <field name="active" />
+                </group>
+                <group>
+                    <field name="team_ids" widget="many2many_tags" readonly="1" />
+                </group>
+            </form>
+        </field>
+    </record>
+
+    <!-- audit.team list view -->
+    <record id="view_audit_team_tree" model="ir.ui.view">
+        <field name="name">audit.team.tree</field>
+        <field name="model">audit.team</field>
+        <field name="arch" type="xml">
+            <list>
+                <field name="name" string="Team Name" />
+                <field name="team_leader_ids" widget="many2many_tags" />
+                <field name="team_member_ids" widget="many2many_tags" />
+            </list>
+        </field>
+    </record>
+
+    <!-- audit.team form view -->
+    <record id="view_audit_team_form" model="ir.ui.view">
+        <field name="name">audit.team.form</field>
+        <field name="model">audit.team</field>
+        <field name="arch" type="xml">
+            <form string="Audit Team">
+                <sheet>
+                    <group>
+                        <field
+                            name="name"
+                            string="Team Name"
+                            class="audit_team_name_field"
+                        />
+                        <field name="team_leader_ids" />
+                        <field name="team_member_ids" />
+                    </group>
+                </sheet>
+            </form>
+        </field>
+    </record>
+
+    <!-- audit.section list view-->
+    <record model="ir.ui.view" id="view_section_tree">
+        <field name="name">Section</field>
+        <field name="model">audit.section</field>
+        <field name="arch" type="xml">
+            <list>
+                <field name="name" string="Section Name" />
+                <field name="question_ids" string="Questions Recorded" />
+            </list>
+        </field>
+    </record>
+
+    <!-- audit.section form view-->
+    <record model="ir.ui.view" id="view_section_form">
+        <field name="name">Section</field>
+        <field name="model">audit.section</field>
+        <field name="type">form</field>
+        <field name="arch" type="xml">
+            <form>
+                <sheet>
+                    <group>
+                        <field name="domain_id" string="Domain Name" />
+                        <field name="name" string="Section Name" />
+                    </group>
+                    <group>
+                        <!-- Each instance of Section can have many instances of Question, each Question has a
+                            field `prompt`.  This then a way to show a field for a One2many field. -->
+                        <field name="question_ids">
+                            <list>
+                                <field name="prompt" />
+                            </list>
+                        </field>
+                    </group>
+                </sheet>
+            </form>
+        </field>
+    </record>
+
+    <!-- audit.question list view -->
+    <record model="ir.ui.view" id="view_question_tree">
+        <field name="name">Question</field>
+        <field name="model">audit.question</field>
+        <field name="arch" type="xml">
+            <list>
+                <field name="prompt" string="Question" />
+            </list>
+        </field>
+    </record>
+
+    <!-- audit.question form view -->
+    <record model="ir.ui.view" id="view_question_form">
+        <field name="name">Question</field>
+        <field name="model">audit.question</field>
+        <field name="type">form</field>
+        <field name="arch" type="xml">
+            <form>
+                <sheet>
+                    <group>
+                        <group>
+                            <field name="section_id" string="Section" />
+                        </group>
+                        <group>
+                            <field name="prompt" string="Question Prompt" />
+                            <field name="answer_type" string="Answer Type" />
+                        </group>
+                    </group>
+                </sheet>
+            </form>
+        </field>
+    </record>
+
+    <!-- audit.snapshot list view -->
+    <record model="ir.ui.view" id="view_snapshot_tree">
+        <field name="name">Audit Snapshots</field>
+        <field name="model">audit.snapshot</field>
+        <field name="arch" type="xml">
+            <list create="false" edit="false">
+                <field name="name" />
+                <field name="inspector_id" />
+                <field name="domain_id" />
+                <field name="target_id" />
+                <field name="locked" />
+                <!-- A quick and easy way to style an element by using attribute `decoration-danger` or `decoration-success`-->
+                <field
+                    name="percentage_score"
+                    widget="percentage"
+                    class="view_snapshot_tree pass-fail-score"
+                    decoration-danger="percentage_score &lt; 0.85"
+                    decoration-success="percentage_score &gt;= 0.85"
+                />
+                <field name="date_conducted" />
+            </list>
+        </field>
+    </record>
+
+    <!-- audit.snapshot form view -->
+    <record model="ir.ui.view" id="view_snapshot_form">
+        <field name="name">Audit Form</field>
+        <field name="model">audit.snapshot</field>
+        <field name="type">form</field>
+        <field name="arch" type="xml">
+            <form>
+                <sheet>
+                    <group>
+                        <field name="domain_id" readonly="1" />
+                        <field name="target_id" />
+                        <field name="inspector_id" />
+                        <field name="date_conducted" />
+                    </group>
+                    <group>
+                        <field name="snapshot_section_ids" />
+                    </group>
+                    <group>
+                        <field name="actual_score" />
+                        <field name="maximum_score" />
+                        <field name="percentage_score" widget="percentage" />
+                    </group>
+                </sheet>
+            </form>
+        </field>
+    </record>
+
+    <!-- audit.snapshot_section form view -->
+    <record model="ir.ui.view" id="view_snapshot_snapshot_section_form">
+        <field name="name">Audit Form</field>
+        <field name="model">audit.snapshot_section</field>
+        <field name="type">form</field>
+        <field name="arch" type="xml">
+            <form>
+                <sheet>
+                    <group>
+                        <field name="name" string="Section" readonly="1" />
+                        <field
+                            name="snapshot_question_ids"
+                            string="Questions"
+                            readonly="0"
+                        />
+                    </group>
+                </sheet>
+            </form>
+        </field>
+    </record>
+
+    <!-- audit.snapshot_section list view -->
+    <record model="ir.ui.view" id="snapshot_section_tree_view">
+        <field name="name">Snapshot Section</field>
+        <field name="model">audit.snapshot_section</field>
+        <field name="arch" type="xml">
+            <list>
+                <field name="snapshot_id" string="Snapshot" />
+                <field name="name" string="Section" readonly="1" />
+                <field name="domain_id" string="Domain" />
+                <field name="snapshot_question_ids" string="Questions" readonly="0" />
+            </list>
+        </field>
+    </record>
+
+    <!-- audit.snapshot_question list view -->
+    <record model="ir.ui.view" id="view_snapshot_question_tree">
+        <field name="name">Question</field>
+        <field name="model">audit.snapshot_question</field>
+        <field name="arch" type="xml">
+            <list>
+                <field name="snapshot_id" />
+                <field name="snapshot_section_id" string="Snapshot Section" />
+                <field name="prompt" string="Question" />
+                <field name="comment" string="Comments" />
+                <field
+                    name="image"
+                    widget="image"
+                    class="oe_avatar"
+                    options="{&apos;size&apos;: [120, 120]}"
+                />
+                <field
+                    name="value"
+                    string="Question Score"
+                    widget="percentage"
+                    class="view_snapshot_tree"
+                />
+            </list>
+        </field>
+    </record>
+
+    <!-- audit.snapshot_question form view -->
+    <record model="ir.ui.view" id="view_snapshot_question_form">
+        <field name="name">Question</field>
+        <field name="model">audit.snapshot_question</field>
+        <field name="type">form</field>
+        <field name="arch" type="xml">
+            <form>
+                <sheet>
+                    <group>
+                        <group>
+                            <field name="snapshot_id" string="Snapshot" readonly="1" />
+                            <field
+                                name="snapshot_section_id"
+                                string="Section"
+                                readonly="1"
+                            />
+                            <field
+                                name="original_question_id"
+                                string="Original Question"
+                                readonly="1"
+                            />
+                        </group>
+                        <group>
+                            <field
+                                name="prompt"
+                                string="Question Prompt"
+                                readonly="1"
+                            />
+                            <field name="answer_type" invisible="1" />
+                            <field
+                                name="answer_yn"
+                                string="Yes/No Answer"
+                                readonly="0"
+                                invisible="answer_type != 'boolean'"
+                            />
+                            <field
+                                name="answer_star"
+                                string="Star Rating Answer"
+                                readonly="0"
+                                invisible="answer_type != 'integer'"
+                            />
+                            <field
+                                name="answer_perc"
+                                string="Percentage Answer"
+                                readonly="0"
+                                invisible="answer_type != 'float'"
+                            />
+                            <field
+                                name="image"
+                                widget="image"
+                                options="{&apos;size&apos;: [120, 120]}"
+                            />
+                            <field name="comment" string="Write a comment" />
+                            <field name="applicable" string="Applicable" />
+                        </group>
+                    </group>
+                </sheet>
+            </form>
+        </field>
+    </record>
+
+    <!-- audit.target list view -->
+    <record id="target_tree_view" model="ir.ui.view">
+        <field name="name">audit.target.tree</field>
+        <field name="model">audit.target</field>
+        <field name="arch" type="xml">
+            <list>
+                <field name="name" />
+                <field
+                    name="all_domain_rel_ids"
+                    string="Linked Domains"
+                    widget="many2many_tags"
+                />
+            </list>
+        </field>
+    </record>
+
+    <!-- audit.target from view -->
+    <record id="target_form_view" model="ir.ui.view">
+        <field name="name">audit.target.form</field>
+        <field name="model">audit.target</field>
+        <field name="arch" type="xml">
+            <form>
+                <header>
+                    <button
+                        name="merge"
+                        class="btn-primary"
+                        string="Merge"
+                        type="object"
+                    />
+                </header>
+                <sheet>
+                    <group>
+                        <field name="name" string="Name" />
+                        <field name="all_domain_rel_ids" string="Linked Domains" />
+                        <field name="snapshot_ids" string="Audit Snapshots" />
+                    </group>
+                </sheet>
+            </form>
+        </field>
+    </record>
+</odoo>
diff --git a/audit/wizards/__init__.py b/audit/wizards/__init__.py
new file mode 100644
index 00000000000..e589b1621a8
--- /dev/null
+++ b/audit/wizards/__init__.py
@@ -0,0 +1,2 @@
+# pylint: disable=missing-module-docstring
+from . import audit_menu_access_control
diff --git a/audit/wizards/audit_menu_access_control.py b/audit/wizards/audit_menu_access_control.py
new file mode 100644
index 00000000000..32d5f22845b
--- /dev/null
+++ b/audit/wizards/audit_menu_access_control.py
@@ -0,0 +1,242 @@
+"""Classes and backend functionality for Audit module menu access control."""
+
+import logging
+
+from odoo import api, models
+
+_logger = logging.getLogger(__name__)
+
+
+class AuditMenuAccessControl(models.TransientModel):
+    """
+    Class and functionality to control what users can see when opening Audit menu items.
+    """
+
+    _name = "audit.menu.access.control"
+    _description = "Simple Audit Menu Access Control"
+
+    @api.model
+    def check_user_access(self, user_id=None):
+        """
+        Simple function to check if current user should have access.
+        """
+        logged_in_user = self.env.user
+        admin_user = logged_in_user.has_group("base.group_system")
+        # Admin users should be able to see and click menu items
+        if admin_user:
+            return logged_in_user, True
+
+        user = self.env["res.users"].search([("id", "=", user_id)])
+        if user:
+            return user, True
+        return None, False
+
+    @api.model
+    def _get_user_inspector(self, user):
+        """
+        Get the inspector record associated with a user.
+        """
+        return self.env["audit.inspector"].search(
+            [("res_user_id", "=", user.id)], limit=1
+        )
+
+    @api.model
+    def _get_team_member_ids(self, user_inspector):
+        """
+        Get all team member IDs from teams where user is a leader.
+        """
+        _teams = self.env["audit.team"].search(
+            [("team_leader_ids", "in", [user_inspector.id])]
+        )
+        if not _teams:
+            return []
+
+        all_team_member_ids = []
+        for team in _teams:
+            # Add team members
+            all_team_member_ids.extend(team.team_member_ids.ids)
+            # Add team leaders (including themselves)
+            all_team_member_ids.extend(team.team_leader_ids.ids)
+
+        # Remove duplicates and ensure user inspector is included
+        all_team_member_ids = list(set(all_team_member_ids))
+        if user_inspector.id not in all_team_member_ids:
+            all_team_member_ids.append(user_inspector.id)
+
+        return all_team_member_ids
+
+    @api.model
+    def _get_inspector_based_domain(self, user, domain_field="inspector_id"):
+        """
+        Get domain for inspector-based access control.
+        domain_field can be: "id", "inspector_id", "snapshot_id.inspector_id"
+        """
+        admin_user = user.has_group("base.group_system")
+
+        if admin_user:
+            return []
+
+        user_inspector = self._get_user_inspector(user)
+        if not user_inspector:
+            return [("id", "=", False)]
+
+        team_member_ids = self._get_team_member_ids(user_inspector)
+        if team_member_ids:
+            # User is team leader - show records from all team members and leaders
+            return [(domain_field, "in", team_member_ids)]
+
+        # User is not team leader - show only their own records
+        return [(domain_field, "=", user_inspector.id)]
+
+    @api.model
+    def _get_team_leadership_domain(self, user):
+        """
+        Get domain for team leadership access control.
+        """
+        admin_user = user.has_group("base.group_system")
+
+        if admin_user:
+            return []
+
+        user_inspector = self._get_user_inspector(user)
+        if not user_inspector:
+            return [("id", "=", False)]
+
+        # Check if inspector is a team leader of any teams
+        team_lead = self.env["audit.team"].search(
+            [("team_leader_ids", "in", [user_inspector.id])]
+        )
+        if team_lead:
+            # User is team leader - show only teams they lead
+            return [("team_leader_ids", "in", [user_inspector.id])]
+
+        # User is not a team leader - show no teams
+        return [("id", "=", False)]
+
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
+    @api.model
+    def _build_standard_action(
+        self,
+        user_id,
+        name,
+        res_model,
+        domain_type="inspector",
+        domain_field="inspector_id",
+        context=None,
+    ):
+        """
+        Build a standard menu action with access control.
+
+        Why not build these actions in XML?  Because building them in Python
+        allows for greater control and customization, logging and tracking of who
+        is trying to enter which menus and when.
+        """
+        user, allow_access = self.check_user_access(user_id=user_id)
+        if allow_access:
+            if domain_type == "team":
+                domain = self._get_team_leadership_domain(user)
+            else:
+                domain = self._get_inspector_based_domain(user, domain_field)
+
+            action = {
+                "name": name,
+                "type": "ir.actions.act_window",
+                "res_model": res_model,
+                "view_mode": "list,form",
+                "target": "current",
+                "domain": domain,
+            }
+
+            if context:
+                action["context"] = context
+
+            return action
+
+        # Show access denied message if not allow_access
+        return {
+            "type": "ir.actions.client",
+            "tag": "display_notification",
+            "params": {
+                "message": self.env._("You may not access this menu item."),
+                "type": "warning",
+                "sticky": False,
+            },
+        }
+
+    @api.model
+    def inspectors_menu_action(self, user_id=None):
+        """
+        Action method that checks access and returns appropriate action
+        """
+        return self._build_standard_action(
+            user_id=user_id,
+            name="Inspectors",
+            res_model="audit.inspector",
+            domain_type="inspector",
+            domain_field="id",
+        )
+
+    @api.model
+    def teams_menu_action(self, user_id=None):
+        """
+        Return the Audit Teams action
+        """
+        return self._build_standard_action(
+            user_id=user_id,
+            name="Audit Teams",
+            res_model="audit.team",
+            domain_type="team",
+        )
+
+    @api.model
+    def snapshots_menu_action(self, user_id=None):
+        """
+        Return the Snapshots Menu Action.
+        """
+        return self._build_standard_action(
+            user_id=user_id,
+            name="Snapshots",
+            res_model="audit.snapshot",
+            domain_type="inspector",
+            domain_field="inspector_id",
+        )
+
+    @api.model
+    def archived_snapshots_menu_action(self, user_id=None):
+        """
+        Return the Archived Snapshots action.
+        """
+        return self._build_standard_action(
+            user_id=user_id,
+            name="Archived Snapshots",
+            res_model="audit.snapshot",
+            domain_type="inspector",
+            domain_field="inspector_id",
+            context={"search_default_archived_snapshots": 1},
+        )
+
+    @api.model
+    def snapshot_sections_menu_action(self, user_id=None):
+        """
+        Return the Snapshot Sections action.
+        """
+        return self._build_standard_action(
+            user_id=user_id,
+            name="Snapshot Sections",
+            res_model="audit.snapshot_section",
+            domain_type="inspector",
+            domain_field="snapshot_id.inspector_id",
+        )
+
+    @api.model
+    def snapshot_questions_menu_action(self, user_id=None):
+        """
+        Return the Snapshot Questions action.
+        """
+        return self._build_standard_action(
+            user_id=user_id,
+            name="Snapshot Questions",
+            res_model="audit.snapshot_question",
+            domain_type="inspector",
+            domain_field="snapshot_id.inspector_id",
+        )
diff --git a/eslint.config.cjs b/eslint.config.cjs
index dd0cbe0aef0..1aa245e64b1 100644
--- a/eslint.config.cjs
+++ b/eslint.config.cjs
@@ -2,6 +2,8 @@ var globals = require('globals');
 jsdoc = require("eslint-plugin-jsdoc");
 
 const config = [{
+    ignores: ["audit/static/src/css/fontawesome.js"],
+}, {
     plugins: {
       jsdoc,
     },
@@ -200,6 +202,18 @@ const config = [{
         ecmaVersion: 2024,
         sourceType: "module",
     },
+}, {
+    files: ["audit/static/src/**/*.js"],
+    languageOptions: {
+        ecmaVersion: 2024,
+        sourceType: "module",
+    },
+    rules: {
+        // `/** @odoo-module **/` is not a standard JSDoc tag
+        "jsdoc/check-tag-names": "off",
+        "no-inline-comments": "off",
+        "sort-imports": "off",
+    },
 }];
 
 module.exports = config