diff --git a/src/actions/bmdashboard/equipmentActions.js b/src/actions/bmdashboard/equipmentActions.js
index d6d5550b30b..6266104ee10 100644
--- a/src/actions/bmdashboard/equipmentActions.js
+++ b/src/actions/bmdashboard/equipmentActions.js
@@ -34,14 +34,14 @@ export const setErrors = payload => {
 export const fetchEquipmentById = equipmentId => {
   const url = `${ENDPOINTS.BM_EQUIPMENT_BY_ID(equipmentId)}`;
   return async dispatch => {
-    axios
-      .get(url)
-      .then(res => {
-        dispatch(setEquipment(res.data));
-      })
-      .catch(error => {
-        dispatch(setErrors(error));
-      });
+    try {
+      const response = await axios.get(url);
+      dispatch(setEquipment(response.data));
+      return response.data;
+    } catch (error) {
+      dispatch(setErrors(error));
+      return { error };
+    }
   };
 };
 
@@ -119,9 +119,7 @@ export const updateEquipment = (equipmentId, updateData) => async (dispatch, get
     }
 
     if (!currentUserId) {
-      const errorMsg = 'User not authenticated. Please log in.';
-      toast.error(errorMsg);
-      throw new Error(errorMsg);
+      throw new Error('User not authenticated. Please log in.');
     }
 
     const statusUpdateData = {
@@ -129,6 +127,7 @@ export const updateEquipment = (equipmentId, updateData) => async (dispatch, get
       lastUsedBy: updateData.lastUsedBy,
       lastUsedFor: updateData.lastUsedFor,
       replacementRequired: updateData.replacementRequired,
+      replacementReason: updateData.replacementReason || '',
       description: updateData.description || '',
       notes: updateData.notes || '',
       createdBy: currentUserId,
@@ -137,7 +136,6 @@ export const updateEquipment = (equipmentId, updateData) => async (dispatch, get
     const res = await axios.put(url, statusUpdateData);
 
     dispatch(setEquipment(res.data));
-    toast.success('Equipment status updated successfully!');
     dispatch(fetchEquipmentById(equipmentId));
 
     return res.data;
@@ -157,7 +155,7 @@ export const updateEquipment = (equipmentId, updateData) => async (dispatch, get
       errorMessage = err.message;
     }
 
-    toast.error(errorMessage);
+    err.message = errorMessage;
     throw err;
   }
 };
diff --git a/src/components/BMDashboard/Equipment/List/EquipmentsTable.jsx b/src/components/BMDashboard/Equipment/List/EquipmentsTable.jsx
index 230b90cecff..ff3a4361c1b 100644
--- a/src/components/BMDashboard/Equipment/List/EquipmentsTable.jsx
+++ b/src/components/BMDashboard/Equipment/List/EquipmentsTable.jsx
@@ -5,13 +5,14 @@ import { BiPencil } from 'react-icons/bi';
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 import { faSortDown, faSortUp } from '@fortawesome/free-solid-svg-icons';
 import ReactTooltip from 'react-tooltip';
-import { Link } from 'react-router-dom';
+import { Link, useHistory } from 'react-router-dom';
 import { fetchAllEquipments } from '~/actions/bmdashboard/equipmentActions';
 import EquipmentListModal from './EquipmentListModal';
 import styles from './Equipments.module.css';
 
 function EquipmentsTable({ equipment, project }) {
   const dispatch = useDispatch();
+  const history = useHistory();
 
   const equipments = useSelector(state => state.bmEquipments.equipmentslist);
   const [recordType, setRecordType] = useState(null);
@@ -181,7 +182,7 @@ function EquipmentsTable({ equipment, project }) {
                   <td className="materials_cell">
                     <button
                       type="button"
-                      onClick={() => handleOpenModal(rec, 'UpdatesEdit')}
+                      onClick={() => history.push(`/bmdashboard/tools/${rec._id}/update`)}
                       aria-label="Edit updates"
                     >
                       <BiPencil />
diff --git a/src/components/BMDashboard/Equipment/List/__tests__/EquipmentsTable.test.jsx b/src/components/BMDashboard/Equipment/List/__tests__/EquipmentsTable.test.jsx
new file mode 100644
index 00000000000..eb9f38022f9
--- /dev/null
+++ b/src/components/BMDashboard/Equipment/List/__tests__/EquipmentsTable.test.jsx
@@ -0,0 +1,81 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import { Router } from 'react-router-dom';
+import { createMemoryHistory } from 'history';
+import configureMockStore from 'redux-mock-store';
+import thunk from 'redux-thunk';
+import EquipmentsTable from '../EquipmentsTable';
+
+vi.mock('~/actions/bmdashboard/equipmentActions', () => ({
+  fetchAllEquipments: () => ({ type: 'MOCK_FETCH_ALL_EQUIPMENTS' }),
+}));
+
+const equipmentslist = [
+  {
+    _id: 'equipment-1',
+    project: { _id: 'project-1', name: 'Community Kitchen' },
+    itemType: { name: 'Cordless Drill' },
+    purchaseStatus: 'Purchased',
+    updateRecord: [
+      {
+        _id: 'update-1',
+        date: '2025-03-05T12:00:00.000Z',
+        createdBy: { _id: 'user-1', firstName: 'Ada', lastName: 'Lovelace' },
+      },
+    ],
+    purchaseRecord: [{ _id: 'purchase-1', date: '2025-01-10T12:00:00.000Z', status: 'Approved' }],
+  },
+  {
+    _id: 'equipment-2',
+    project: { _id: 'project-2', name: 'Garden' },
+    itemType: { name: 'Shovel' },
+    purchaseStatus: 'Rental',
+    updateRecord: [],
+    purchaseRecord: [],
+  },
+];
+
+const setupTable = () => {
+  const history = createMemoryHistory({ initialEntries: ['/bmdashboard/equipment'] });
+  const store = configureMockStore([thunk])({ bmEquipments: { equipmentslist } });
+  render(
+    <Provider store={store}>
+      <Router history={history}>
+        <EquipmentsTable equipment={[]} project={[]} />
+      </Router>
+    </Provider>,
+  );
+  return { history };
+};
+
+describe('EquipmentsTable', () => {
+  it('renders a row per equipment with detail links', () => {
+    setupTable();
+    expect(screen.getByRole('link', { name: 'Cordless Drill' }).getAttribute('href')).toBe(
+      '/bmdashboard/equipment/equipment-1',
+    );
+    expect(screen.getByText('Shovel')).toBeInTheDocument();
+  });
+
+  it('navigates to the status update form for the clicked equipment', () => {
+    const { history } = setupTable();
+    fireEvent.click(screen.getAllByLabelText('Edit updates')[1]);
+    expect(history.location.pathname).toBe('/bmdashboard/tools/equipment-2/update');
+    expect(screen.queryByText(/Edit Record/)).not.toBeInTheDocument();
+  });
+
+  it('opens update history from the UPDATES View button', () => {
+    const { history } = setupTable();
+    fireEvent.click(screen.getAllByRole('button', { name: 'View' })[0]);
+    expect(screen.getByText(/Update History/)).toBeInTheDocument();
+    expect(screen.getByText('Ada Lovelace')).toBeInTheDocument();
+    expect(history.location.pathname).toBe('/bmdashboard/equipment');
+  });
+
+  it('opens purchase history from the PURCHASES View button', () => {
+    setupTable();
+    fireEvent.click(screen.getAllByRole('button', { name: 'View' })[1]);
+    expect(screen.getByText(/Purchase History/)).toBeInTheDocument();
+    expect(screen.getByText('Approved')).toBeInTheDocument();
+  });
+});
diff --git a/src/components/BMDashboard/Equipment/Update/UpdateEquipment.jsx b/src/components/BMDashboard/Equipment/Update/UpdateEquipment.jsx
index 91555de85a1..26574544a07 100644
--- a/src/components/BMDashboard/Equipment/Update/UpdateEquipment.jsx
+++ b/src/components/BMDashboard/Equipment/Update/UpdateEquipment.jsx
@@ -1,6 +1,13 @@
-import { useEffect, useState, useCallback, useMemo } from 'react';
+import { useEffect, useState, useCallback, useMemo, useRef } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 import { fetchEquipmentById, updateEquipment } from '~/actions/bmdashboard/equipmentActions';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import {
+  faCheckCircle,
+  faExclamationCircle,
+  faInfoCircle,
+  faSyncAlt,
+} from '@fortawesome/free-solid-svg-icons';
 import { Button, Form, FormGroup, Label, Container, Row, Col, Input, Alert } from 'reactstrap';
 import CheckTypesModal from '~/components/BMDashboard/shared/CheckTypesModal';
 import { useHistory, useParams } from 'react-router-dom';
@@ -11,6 +18,65 @@ import FilePreview from '~/components/common/FilePreview/FilePreview'; // Import
 import styles from './UpdateEquipment.module.css';
 import styles1 from '../../BMDashboard.module.css';
 
+// Display labels are kept for users; the stored value must match the backend condition enum.
+const STATUS_OPTIONS = [
+  { label: 'Working well', value: 'Good' },
+  { label: 'Broken/Needs repair', value: 'Needs Repair' },
+  { label: 'Stolen/Lost', value: 'Out of Order' },
+  { label: 'End of life', value: 'Out of Order' },
+  { label: 'Returned', value: 'Good' },
+];
+
+// Saved records hold either a legacy label or a canonical value; return the matching dropdown label.
+const toStatusLabel = condition =>
+  (
+    STATUS_OPTIONS.find(o => o.label === condition) ||
+    STATUS_OPTIONS.find(o => o.value === condition)
+  )?.label || '';
+
+const toStoredStatus = label => STATUS_OPTIONS.find(o => o.label === label)?.value || label;
+
+const getLatestRecord = (records, predicate = () => true) =>
+  (Array.isArray(records) ? records : []).reduce((latest, record) => {
+    if (!predicate(record)) return latest;
+    const timestamp = Date.parse(record?.date);
+    if (!Number.isFinite(timestamp)) return latest;
+    return !latest || timestamp >= Date.parse(latest.date) ? record : latest;
+  }, null);
+
+const getDisplayName = user => {
+  if (typeof user === 'string') return /^[a-f\d]{24}$/i.test(user) ? '' : user;
+  if (!user || typeof user !== 'object') return '';
+  return [user.firstName, user.lastName]
+    .filter(Boolean)
+    .join(' ')
+    .trim();
+};
+
+const formatHistoryDate = date => {
+  const parsedDate = new Date(date);
+  return Number.isNaN(parsedDate.getTime())
+    ? 'Unknown'
+    : new Intl.DateTimeFormat(undefined, { dateStyle: 'medium' }).format(parsedDate);
+};
+
+// Most recent known user: a populated Check Out log entry or a saved status update's lastUsedBy.
+const getLatestKnownUser = equipment => {
+  const checkOut = getLatestRecord(
+    equipment?.logRecord,
+    record => record?.type === 'Check Out' && Boolean(getDisplayName(record.responsibleUser)),
+  );
+  const savedUpdate = getLatestRecord(equipment?.updateRecord, record =>
+    Boolean(getDisplayName(record?.lastUsedBy).trim()),
+  );
+  const checkOutName = getDisplayName(checkOut?.responsibleUser);
+  const savedName = getDisplayName(savedUpdate?.lastUsedBy).trim();
+  if (checkOutName && savedName) {
+    return Date.parse(savedUpdate.date) > Date.parse(checkOut.date) ? savedName : checkOutName;
+  }
+  return checkOutName || savedName;
+};
+
 export default function UpdateEquipment() {
   const history = useHistory();
   const { equipmentId } = useParams();
@@ -20,6 +86,7 @@ export default function UpdateEquipment() {
   const [lastUsedFor, setLastUsedFor] = useState('');
   const [lastUsedForOther, setLastUsedForOther] = useState('');
   const [replacementRequired, setReplacementRequired] = useState('');
+  const [replacementReason, setReplacementReason] = useState('');
   const [description, setDescription] = useState('');
   const [sendNote, setSendNote] = useState('');
   const [status, setStatus] = useState('');
@@ -28,10 +95,27 @@ export default function UpdateEquipment() {
   const [isSubmitting, setIsSubmitting] = useState(false);
   const [submitError, setSubmitError] = useState('');
   const [submitSuccess, setSubmitSuccess] = useState('');
+  const [imageError, setImageError] = useState('');
   const [uploadedFilesPreview, setUploadedFilesPreview] = useState([]);
   const [isUpdated, setIsUpdated] = useState(false);
-
-  const equipmentDetails = useSelector(state => state.bmEquipments.singleEquipment);
+  const [historyState, setHistoryState] = useState({
+    equipmentId: null,
+    status: 'loading',
+    equipment: null,
+  });
+  const previewFilesRef = useRef([]);
+  const historyRequestIdRef = useRef(0);
+  const isSubmittingRef = useRef(false);
+  const feedbackRef = useRef(null);
+  const editedHistoryFieldsRef = useRef({
+    equipmentId: null,
+    lastUsedBy: false,
+    lastUsedFor: false,
+  });
+
+  const storedEquipmentDetails = useSelector(state => state.bmEquipments.singleEquipment);
+  const equipmentDetails =
+    storedEquipmentDetails?._id === equipmentId ? storedEquipmentDetails : null;
   const darkMode = useSelector(state => state.theme.darkMode);
   const dispatch = useDispatch();
 
@@ -45,43 +129,85 @@ export default function UpdateEquipment() {
   }, []);
 
   useEffect(() => {
-    if (equipmentId) {
-      dispatch(fetchEquipmentById(equipmentId));
+    const requestId = ++historyRequestIdRef.current;
+    let active = true;
+    editedHistoryFieldsRef.current = {
+      equipmentId,
+      lastUsedBy: false,
+      lastUsedFor: false,
+    };
+    setLastUsedBy('');
+    setLastUsedByOther('');
+    setLastUsedFor('');
+    setLastUsedForOther('');
+    setStatus('');
+    setReplacementRequired('');
+    setReplacementReason('');
+    setDescription('');
+    setNotes('');
+    setSendNote('');
+    setUploadedFiles([]);
+    setUploadedFilesPreview([]);
+    previewFilesRef.current = [];
+    setSubmitError('');
+    setSubmitSuccess('');
+    setImageError('');
+    setIsUpdated(false);
+    setHistoryState({ equipmentId, status: 'loading', equipment: null });
+
+    if (!equipmentId) {
+      setHistoryState({ equipmentId, status: 'error', equipment: null });
+      return undefined;
     }
 
-    return () => {
-      cleanupFilePreviews(uploadedFilesPreview);
-    };
-  }, [dispatch, equipmentId, uploadedFilesPreview, cleanupFilePreviews]);
+    dispatch(fetchEquipmentById(equipmentId)).then(result => {
+      if (!active || requestId !== historyRequestIdRef.current) return;
+      if (result?.error || result?._id !== equipmentId) {
+        setHistoryState({ equipmentId, status: 'error', equipment: null });
+        return;
+      }
+
+      setHistoryState({ equipmentId, status: 'loaded', equipment: result });
+      const latestStatus = getLatestRecord(result.updateRecord);
+      const latestPurpose = getLatestRecord(
+        result.updateRecord,
+        record => typeof record?.lastUsedFor === 'string' && record.lastUsedFor.trim().length > 0,
+      );
+
+      if (!editedHistoryFieldsRef.current.lastUsedBy) {
+        setLastUsedBy(getLatestKnownUser(result));
+      }
+      if (!editedHistoryFieldsRef.current.lastUsedFor) {
+        setLastUsedFor(latestPurpose?.lastUsedFor || '');
+      }
+      if (latestStatus) {
+        setStatus(toStatusLabel(latestStatus.condition));
+        setReplacementRequired(latestStatus.replacementRequired || '');
+        setReplacementReason(latestStatus.replacementReason || '');
+        setDescription(latestStatus.description || '');
+        setNotes(latestStatus.notes || '');
+        setSendNote(latestStatus.notes ? 'yes' : 'no');
+      }
+    });
 
-  useEffect(() => {
     return () => {
-      cleanupFilePreviews(uploadedFilesPreview);
+      active = false;
+      cleanupFilePreviews(previewFilesRef.current);
+      previewFilesRef.current = [];
     };
-  }, [uploadedFilesPreview, cleanupFilePreviews]);
+  }, [dispatch, equipmentId, cleanupFilePreviews]);
 
-  // Reset form when equipment details are updated
   useEffect(() => {
-    if (equipmentDetails && isUpdated) {
-      const lastUpdate = equipmentDetails?.updateRecord?.[equipmentDetails.updateRecord.length - 1];
-      if (lastUpdate) {
-        setStatus(lastUpdate.condition || '');
-        setLastUsedBy(lastUpdate.lastUsedBy || '');
-        setLastUsedFor(lastUpdate.lastUsedFor || '');
-        setReplacementRequired(lastUpdate.replacementRequired || '');
-        setDescription(lastUpdate.description || '');
-        setNotes(lastUpdate.notes || '');
-        setSendNote(lastUpdate.notes ? 'yes' : 'no');
-      }
+    if (!isUpdated) return undefined;
+    const timer = setTimeout(() => setIsUpdated(false), 5000);
+    return () => clearTimeout(timer);
+  }, [isUpdated]);
 
-      const timer = setTimeout(() => {
-        setSubmitSuccess('');
-        setIsUpdated(false);
-      }, 5000);
-
-      return () => clearTimeout(timer);
+  useEffect(() => {
+    if ((submitError || submitSuccess) && feedbackRef.current?.scrollIntoView) {
+      feedbackRef.current.scrollIntoView({ block: 'nearest', behavior: 'smooth' });
     }
-  }, [equipmentDetails, isUpdated]);
+  }, [submitError, submitSuccess]);
 
   const handleCancel = useCallback(() => history.goBack(), [history]);
 
@@ -100,24 +226,20 @@ export default function UpdateEquipment() {
   }, []);
 
   const validateForm = useCallback(() => {
-    const validations = [
-      [!status, 'Status/Condition is required'],
-      [!lastUsedBy, 'Please specify who used the tool/equipment last time'],
-      [
-        lastUsedBy === 'other' && !lastUsedByOther.trim(),
-        'Please specify the name of who used the tool/equipment',
-      ],
-      [!lastUsedFor, 'Please specify what the tool/equipment was used for'],
-      [
-        lastUsedFor === 'other' && !lastUsedForOther.trim(),
-        'Please specify what the tool/equipment was used for',
-      ],
-      [!replacementRequired, 'Please indicate if replacement is required'],
-      [sendNote === 'yes' && !notes.trim(), 'Please add a note if you selected to send one'],
+    const checks = [
+      [!status, 'Status/Condition'],
+      [!lastUsedBy, 'Who used the tool/equipment last time'],
+      [lastUsedBy === 'other' && !lastUsedByOther.trim(), 'Name of the last user'],
+      [!lastUsedFor, 'What it was used for last time'],
+      [lastUsedFor === 'other' && !lastUsedForOther.trim(), 'Description of the last use'],
+      [!replacementRequired, 'Replacement required'],
+      [replacementRequired === 'yes' && !replacementReason.trim(), 'Replacement reason'],
+      [sendNote === 'yes' && !notes.trim(), 'Note'],
     ];
-
-    const failedValidation = validations.find(([condition]) => condition);
-    return failedValidation ? failedValidation[1] : null;
+    const missing = checks.filter(([isMissing]) => isMissing).map(([, label]) => label);
+    return missing.length > 0
+      ? `Please complete the following required fields: ${missing.join(', ')}.`
+      : null;
   }, [
     status,
     lastUsedBy,
@@ -125,81 +247,90 @@ export default function UpdateEquipment() {
     lastUsedFor,
     lastUsedForOther,
     replacementRequired,
+    replacementReason,
     sendNote,
     notes,
   ]);
 
   const handleFileUpload = useCallback(
     files => {
-      cleanupFilePreviews(uploadedFilesPreview);
-
       const validFiles = files.filter(file => {
         const fileType = file.type || '';
         const fileName = file.name || '';
-        const isValidType = fileType.startsWith('image/');
+        const isValidType = /^image\/(jpeg|jpg|png|gif|webp)$/i.test(fileType);
         const isValidExtension = fileName.match(/\.(jpg|jpeg|png|gif|webp)$/i);
         return isValidType || isValidExtension;
       });
 
       if (validFiles.length === 0) {
-        console.warn('No valid image files found');
+        setImageError('Please select a PNG, JPG, JPEG, GIF, or WEBP image.');
         return;
       }
 
-      const newPreviews = validFiles.map(file => ({
-        name: file.name || 'Image',
-        preview: URL.createObjectURL(file),
-        size: file.size || 0,
-        type: file.type || 'image/*',
-        file: file,
-        status: 'uploaded',
-        uploadedAt: new Date().toISOString(),
-      }));
-
-      setUploadedFiles(prev => [...prev, ...validFiles]);
-      setUploadedFilesPreview(prev => [...prev, ...newPreviews]);
+      setImageError('');
+      cleanupFilePreviews(previewFilesRef.current);
+      const file = validFiles[0];
+      const newPreviews = [
+        {
+          name: file.name || 'Image',
+          preview: URL.createObjectURL(file),
+          size: file.size || 0,
+          type: file.type || 'image/*',
+          file,
+          status: 'not-saved',
+          message: 'Preview only; this image is not saved with the status update.',
+          uploadedAt: new Date().toISOString(),
+        },
+      ];
+
+      previewFilesRef.current = newPreviews;
+      setUploadedFiles([file]);
+      setUploadedFilesPreview(newPreviews);
     },
-    [uploadedFilesPreview, cleanupFilePreviews],
+    [cleanupFilePreviews],
   );
 
   const handleSubmit = useCallback(
     async e => {
       e.preventDefault();
+      if (isSubmittingRef.current) return;
 
       const validationError = validateForm();
       if (validationError) {
+        setSubmitSuccess('');
         setSubmitError(validationError);
         return;
       }
 
+      isSubmittingRef.current = true;
       setIsSubmitting(true);
       setSubmitError('');
       setSubmitSuccess('');
 
       try {
         const updateData = {
-          condition: status,
+          condition: toStoredStatus(status),
           lastUsedBy: lastUsedBy === 'other' ? lastUsedByOther : lastUsedBy,
           lastUsedFor: lastUsedFor === 'other' ? lastUsedForOther : lastUsedFor,
           replacementRequired,
+          replacementReason: replacementRequired === 'yes' ? replacementReason.trim() : '',
           description,
           notes: sendNote === 'yes' ? notes : '',
         };
 
-        await dispatch(updateEquipment(equipmentId, updateData));
-        dispatch(fetchEquipmentById(equipmentId));
+        const savedEquipment = await dispatch(updateEquipment(equipmentId, updateData));
+        setHistoryState({ equipmentId, status: 'loaded', equipment: savedEquipment });
         setIsUpdated(true);
 
-        let successMessage = 'Equipment status updated successfully!';
-
-        if (uploadedFiles.length > 0) {
-          successMessage += ' The form has been updated.';
-          cleanupFilePreviews(uploadedFilesPreview);
-          setUploadedFiles([]);
-          setUploadedFilesPreview([]);
-        }
-
-        setSubmitSuccess(successMessage);
+        const savedStatus = getLatestRecord(savedEquipment?.updateRecord);
+        const toolName = savedEquipment?.itemType?.name || 'Equipment';
+        const replacementText =
+          savedStatus?.replacementRequired === 'yes'
+            ? `Replacement required. Reason: ${savedStatus.replacementReason}`
+            : 'Replacement not required.';
+        setSubmitSuccess(
+          `${toolName} status saved as ${savedStatus?.condition || 'Unknown'}. ${replacementText}`,
+        );
 
         if (lastUsedBy === 'other') setLastUsedByOther('');
         if (lastUsedFor === 'other') setLastUsedForOther('');
@@ -207,12 +338,18 @@ export default function UpdateEquipment() {
         console.error('Update failed:', error);
 
         let errorMessage = 'Failed to update equipment. Please try again.';
+        const serverMessage = error.response?.data?.error;
 
-        if (error.message?.includes('User not authenticated')) {
+        if (error.message?.includes('User not authenticated') || error.response?.status === 401) {
           errorMessage = 'Authentication error. Please check if you are logged in.';
-        } else if (error.response?.data?.error?.includes('Invalid user ID format')) {
+        } else if (serverMessage?.includes('Invalid user ID format')) {
           errorMessage = 'User ID format error. Please contact support.';
+        } else if (typeof serverMessage === 'string' && serverMessage) {
+          errorMessage = `Failed to update equipment: ${serverMessage}`;
+        } else if (error.request && !error.response) {
+          errorMessage = 'Failed to update equipment: no response from server. Please try again.';
         }
+        errorMessage += ' Your entries have been kept and nothing was saved.';
 
         if (uploadedFiles.length > 0) {
           errorMessage += ' Note: Images were selected and previewed but not saved to database.';
@@ -227,6 +364,7 @@ export default function UpdateEquipment() {
 
         setSubmitError(errorMessage);
       } finally {
+        isSubmittingRef.current = false;
         setIsSubmitting(false);
       }
     },
@@ -238,6 +376,7 @@ export default function UpdateEquipment() {
       lastUsedFor,
       lastUsedForOther,
       replacementRequired,
+      replacementReason,
       description,
       sendNote,
       notes,
@@ -249,18 +388,17 @@ export default function UpdateEquipment() {
     ],
   );
 
-  const handleRemoveFile = useCallback(
-    index => {
-      const fileToRemove = uploadedFilesPreview[index];
-      if (fileToRemove?.preview?.startsWith?.('blob:')) {
-        URL.revokeObjectURL(fileToRemove.preview);
-      }
+  const handleRemoveFile = useCallback(index => {
+    const fileToRemove = previewFilesRef.current[index];
+    if (fileToRemove?.preview?.startsWith?.('blob:')) {
+      URL.revokeObjectURL(fileToRemove.preview);
+    }
 
-      setUploadedFilesPreview(prev => prev.filter((_, i) => i !== index));
-      setUploadedFiles(prev => prev.filter((_, i) => i !== index));
-    },
-    [uploadedFilesPreview],
-  );
+    const remainingPreviews = previewFilesRef.current.filter((_, i) => i !== index);
+    previewFilesRef.current = remainingPreviews;
+    setUploadedFilesPreview(remainingPreviews);
+    setUploadedFiles(remainingPreviews.map(file => file.file));
+  }, []);
 
   // Memoized styles
   const formLabelStyle = useMemo(
@@ -366,15 +504,25 @@ export default function UpdateEquipment() {
 
   // Derived values
   const currentStatus = useMemo(
-    () =>
-      equipmentDetails?.updateRecord?.[equipmentDetails.updateRecord.length - 1]?.condition ||
-      'Unknown',
+    () => getLatestRecord(equipmentDetails?.updateRecord)?.condition || 'Unknown',
     [equipmentDetails],
   );
 
   const rentalDueDate = useMemo(() => equipmentDetails?.rentalDueDate?.split('T')[0] || 'Unknown', [
     equipmentDetails,
   ]);
+  const summaryEquipment =
+    historyState.status === 'loaded' && historyState.equipmentId === equipmentId
+      ? historyState.equipment
+      : null;
+  const latestSummaryUpdate = getLatestRecord(summaryEquipment?.updateRecord);
+  const latestSummaryUser = getLatestKnownUser(summaryEquipment);
+  const hasStatusHistory = Array.isArray(summaryEquipment?.updateRecord)
+    ? summaryEquipment.updateRecord.length > 0
+    : false;
+  const hasUsageHistory = Array.isArray(summaryEquipment?.logRecord)
+    ? summaryEquipment.logRecord.length > 0
+    : false;
 
   const hasUploadedFiles = uploadedFiles.length > 0;
   const hasFilePreviews = uploadedFilesPreview.length > 0;
@@ -392,7 +540,7 @@ export default function UpdateEquipment() {
             </h1>
             {isUpdated && (
               <output className="text-success mt-2 d-block" style={{ fontSize: '0.9rem' }}>
-                <i className="fas fa-sync-alt me-2" />
+                <FontAwesomeIcon icon={faSyncAlt} className="mr-2" aria-hidden="true" />
                 Showing updated data for Equipment ID: {equipmentId}
               </output>
             )}
@@ -400,55 +548,6 @@ export default function UpdateEquipment() {
         </Col>
       </Row>
 
-      {submitError && (
-        <Row>
-          <Col md={12}>
-            <Alert
-              color="danger"
-              className="mt-3"
-              style={{
-                backgroundColor: darkMode ? '#5c1a1a' : '#f8d7da',
-                borderColor: darkMode ? '#f5c2c7' : '#f1aeb5',
-                color: darkMode ? '#f8d7da' : '#842029',
-              }}
-            >
-              <i className="fas fa-exclamation-circle me-2" />
-              {submitError}
-            </Alert>
-          </Col>
-        </Row>
-      )}
-
-      {submitSuccess && (
-        <Row>
-          <Col md={12}>
-            <Alert
-              color="success"
-              className="mt-3"
-              style={{
-                backgroundColor: darkMode ? '#0a3a27' : '#d1e7dd',
-                borderColor: darkMode ? '#badbcc' : '#a3cfbb',
-                color: darkMode ? '#d1e7dd' : '#0f5132',
-              }}
-            >
-              <i className="fas fa-check-circle me-2" />
-              {submitSuccess}
-              <div className="mt-2 small">
-                You can continue editing or{' '}
-                <Button
-                  color="link"
-                  className="p-0"
-                  onClick={() => history.push(`/bmdashboard/tools/${equipmentId}`)}
-                  style={{ color: darkMode ? '#0dcaf0' : '#0d6efd' }}
-                >
-                  view the equipment details
-                </Button>
-              </div>
-            </Alert>
-          </Col>
-        </Row>
-      )}
-
       {equipmentDetails && (
         <Row className="mb-4">
           <Col md={3}>
@@ -466,7 +565,38 @@ export default function UpdateEquipment() {
         </Row>
       )}
 
-      <Form className={`${styles1.invForm}`} onSubmit={handleSubmit}>
+      <Row>
+        <Col md={12}>
+          <Alert color="info" className={`mb-4 ${styles.lastUpdateSummary}`} aria-live="polite">
+            <h2 className={`h5 ${styles.lastUpdateSummaryTitle}`}>Last Update Summary</h2>
+            {historyState.status === 'loading' && (
+              <p className="mb-0">Loading equipment history…</p>
+            )}
+            {historyState.status === 'error' && (
+              <p className="mb-0">Equipment history could not be loaded.</p>
+            )}
+            {historyState.status === 'loaded' && !hasStatusHistory && !hasUsageHistory && (
+              <p className="mb-0">No previous status or usage history.</p>
+            )}
+            {historyState.status === 'loaded' && (hasStatusHistory || hasUsageHistory) && (
+              <dl className="mb-0">
+                <dt>Last update date</dt>
+                <dd>
+                  {latestSummaryUpdate?.date
+                    ? formatHistoryDate(latestSummaryUpdate.date)
+                    : 'Unknown'}
+                </dd>
+                <dt>Previous status/condition</dt>
+                <dd>{latestSummaryUpdate?.condition || 'Unknown'}</dd>
+                <dt>Last known user</dt>
+                <dd>{latestSummaryUser || 'Unknown'}</dd>
+              </dl>
+            )}
+          </Alert>
+        </Col>
+      </Row>
+
+      <Form className={`${styles1.invForm}`} onSubmit={handleSubmit} noValidate>
         <FormGroup className="background-from-db">
           <Row form>
             <Col md={4}>
@@ -549,11 +679,11 @@ export default function UpdateEquipment() {
                 className={styles['custom-select']}
               >
                 <option value="">Select status</option>
-                <option value="Working well">Working well</option>
-                <option value="Broken/Needs repair">Broken/Needs repair</option>
-                <option value="Stolen/Lost">Stolen/Lost</option>
-                <option value="End of life">End of life</option>
-                <option value="Returned">Returned</option>
+                {STATUS_OPTIONS.map(option => (
+                  <option key={option.label} value={option.label}>
+                    {option.label}
+                  </option>
+                ))}
               </Input>
             </FormGroup>
           </Col>
@@ -568,7 +698,10 @@ export default function UpdateEquipment() {
                 name="lastUsedBy"
                 id="lastUsedBy"
                 value={lastUsedBy}
-                onChange={e => setLastUsedBy(e.target.value)}
+                onChange={e => {
+                  editedHistoryFieldsRef.current.lastUsedBy = true;
+                  setLastUsedBy(e.target.value);
+                }}
                 required
                 style={selectInputStyle}
                 className={styles['custom-select']}
@@ -578,6 +711,14 @@ export default function UpdateEquipment() {
                 <option value="Jane Doe (Volunteer #2)">Jane Doe (Volunteer #2)</option>
                 <option value="Jane Doe (Volunteer #3)">Jane Doe (Volunteer #3)</option>
                 <option value="Jane Doe (Volunteer #4)">Jane Doe (Volunteer #4)</option>
+                {lastUsedBy &&
+                  ![
+                    'Jane Doe (Volunteer #1)',
+                    'Jane Doe (Volunteer #2)',
+                    'Jane Doe (Volunteer #3)',
+                    'Jane Doe (Volunteer #4)',
+                    'other',
+                  ].includes(lastUsedBy) && <option value={lastUsedBy}>{lastUsedBy}</option>}
                 <option value="other">Other (Please specify below)</option>
               </Input>
               {lastUsedBy === 'other' && (
@@ -608,7 +749,10 @@ export default function UpdateEquipment() {
                 name="lastUsedFor"
                 id="lastUsedFor"
                 value={lastUsedFor}
-                onChange={e => setLastUsedFor(e.target.value)}
+                onChange={e => {
+                  editedHistoryFieldsRef.current.lastUsedFor = true;
+                  setLastUsedFor(e.target.value);
+                }}
                 required
                 style={selectInputStyle}
                 className={styles['custom-select']}
@@ -618,6 +762,14 @@ export default function UpdateEquipment() {
                 <option value="Bathroom - plumbing">Bathroom - plumbing</option>
                 <option value="Living room - painting">Living room - painting</option>
                 <option value="Garden - landscaping">Garden - landscaping</option>
+                {lastUsedFor &&
+                  ![
+                    'Kitchen - tiling',
+                    'Bathroom - plumbing',
+                    'Living room - painting',
+                    'Garden - landscaping',
+                    'other',
+                  ].includes(lastUsedFor) && <option value={lastUsedFor}>{lastUsedFor}</option>}
                 <option value="other">Other (Please specify below)</option>
               </Input>
               {lastUsedFor === 'other' && (
@@ -652,15 +804,35 @@ export default function UpdateEquipment() {
               { label: 'No', value: 'no', id: 'replacementRequired-no' },
             ]}
             value={replacementRequired}
-            onChange={e => setReplacementRequired(e.target.value)}
+            onChange={e => {
+              setReplacementRequired(e.target.value);
+              if (e.target.value !== 'yes') setReplacementReason('');
+            }}
             required
             darkMode={darkMode}
           />
         </FormGroup>
 
+        {replacementRequired === 'yes' && (
+          <FormGroup>
+            <Label for="replacementReason" style={formLabelStyle}>
+              Replacement reason *
+            </Label>
+            <Input
+              type="textarea"
+              name="replacementReason"
+              id="replacementReason"
+              value={replacementReason}
+              onChange={e => setReplacementReason(e.target.value)}
+              required
+              style={textInputStyle}
+            />
+          </FormGroup>
+        )}
+
         <FormGroup>
           <Label for="file-upload-input" style={formLabelStyle}>
-            Upload latest picture of this tool or equipment. (optional)
+            Select one picture for preview (optional; not saved)
             <small className="text-muted ms-2" style={{ color: darkMode ? '#b0b7c0' : '#6c757d' }}>
               Accepted: PNG, JPG, JPEG, GIF, WEBP
             </small>
@@ -676,13 +848,18 @@ export default function UpdateEquipment() {
                 color: darkMode ? '#d1ecf1' : '#0c5460',
               }}
             >
-              <i className="fas fa-info-circle me-2" />
-              {uploadedFiles.length} image{uploadedFiles.length > 1 ? 's' : ''} uploaded and ready
-              for preview
+              <FontAwesomeIcon icon={faInfoCircle} className="mr-2" aria-hidden="true" />
+              {uploadedFiles.length} image selected for preview only; it will not be saved with this
+              update.
             </Alert>
           )}
 
-          <DragAndDrop updateUploadedFiles={handleFileUpload} />
+          <DragAndDrop updateUploadedFiles={handleFileUpload} multiple={false} />
+          {imageError && (
+            <Alert color="danger" className="mt-2" role="alert">
+              {imageError}
+            </Alert>
+          )}
 
           {hasFilePreviews && (
             <div className="mt-3">
@@ -717,7 +894,7 @@ export default function UpdateEquipment() {
                   }
                 >
                   <small>
-                    <i className="fas fa-info-circle me-1" />
+                    <FontAwesomeIcon icon={faInfoCircle} className="mr-1" aria-hidden="true" />
                     {hasNotSavedFiles
                       ? 'Images are shown for preview purposes only and are not saved to the database.'
                       : 'Images are uploaded for preview. Form data will be saved to database.'}
@@ -779,6 +956,50 @@ export default function UpdateEquipment() {
           </FormGroup>
         )}
 
+        <div ref={feedbackRef} aria-live="polite" data-testid="submit-feedback">
+          {submitError && (
+            <Alert
+              color="danger"
+              role="alert"
+              className="mt-3"
+              style={{
+                backgroundColor: darkMode ? '#5c1a1a' : '#f8d7da',
+                borderColor: darkMode ? '#f5c2c7' : '#f1aeb5',
+                color: darkMode ? '#f8d7da' : '#842029',
+              }}
+            >
+              <FontAwesomeIcon icon={faExclamationCircle} className="mr-2" aria-hidden="true" />
+              {submitError}
+            </Alert>
+          )}
+          {submitSuccess && (
+            <Alert
+              color="success"
+              className="mt-3"
+              style={{
+                backgroundColor: darkMode ? '#0a3a27' : '#d1e7dd',
+                borderColor: darkMode ? '#badbcc' : '#a3cfbb',
+                color: darkMode ? '#d1e7dd' : '#0f5132',
+              }}
+            >
+              <FontAwesomeIcon icon={faCheckCircle} className="mr-2" aria-hidden="true" />
+              {submitSuccess}
+              <div className="mt-2 small">
+                You can continue editing or{' '}
+                <Button
+                  color="link"
+                  className="p-0"
+                  onClick={() => history.push(`/bmdashboard/equipment/${equipmentId}`)}
+                  style={{ color: darkMode ? '#0dcaf0' : '#0d6efd' }}
+                >
+                  view the equipment details
+                </Button>
+                .
+              </div>
+            </Alert>
+          )}
+        </div>
+
         <FormGroup>
           <div className={`${styles1.invFormBtnGroup}`}>
             <Button
@@ -790,39 +1011,18 @@ export default function UpdateEquipment() {
             >
               Cancel
             </Button>
-            <Button
-              color="primary"
-              type="submit"
-              disabled={isSubmitting}
-              className="position-relative"
-              style={buttonStyle}
-            >
+            <Button color="primary" type="submit" disabled={isSubmitting} style={buttonStyle}>
               {isSubmitting ? (
                 <>
                   <span
-                    className="spinner-border spinner-border-sm me-2"
+                    className="spinner-border spinner-border-sm mr-2"
                     role="status"
                     aria-hidden="true"
                   />
-                  Updating...
+                  Saving...
                 </>
               ) : (
-                <>
-                  <i className="fas fa-save me-2" />
-                  Update Status
-                  {hasUploadedFiles && (
-                    <span
-                      className="position-absolute top-0 start-100 translate-middle badge rounded-pill"
-                      style={{
-                        backgroundColor: darkMode ? '#0dcaf0' : '#0d6efd',
-                        color: darkMode ? '#000' : '#fff',
-                      }}
-                    >
-                      <i className="fas fa-image me-1" />
-                      {uploadedFiles.length}
-                    </span>
-                  )}
-                </>
+                'Update Status'
               )}
             </Button>
           </div>
diff --git a/src/components/BMDashboard/Equipment/Update/UpdateEquipment.module.css b/src/components/BMDashboard/Equipment/Update/UpdateEquipment.module.css
index bf70a95b3e6..ec9f426c8b7 100644
--- a/src/components/BMDashboard/Equipment/Update/UpdateEquipment.module.css
+++ b/src/components/BMDashboard/Equipment/Update/UpdateEquipment.module.css
@@ -235,4 +235,22 @@
 
 :global(.dark-mode) .form-control::placeholder {
   color: #b0b7c0 !important;
-}
\ No newline at end of file
+}
+
+/* Last Update Summary: light-blue panel with dark navy text (about 13:1) in light and dark mode */
+.lastUpdateSummary,
+.lastUpdateSummary dt,
+.lastUpdateSummary dd,
+.lastUpdateSummary p {
+  color: #0a2540 !important;
+}
+
+:global(.dark-mode) .lastUpdateSummary .lastUpdateSummaryTitle,
+.lastUpdateSummaryTitle {
+  color: #0a2540 !important;
+}
+
+.lastUpdateSummary {
+  background-color: #d1ecf1 !important;
+  border-color: #bee5eb !important;
+}
diff --git a/src/components/BMDashboard/Equipment/Update/__tests__/UpdateEquipment.test.jsx b/src/components/BMDashboard/Equipment/Update/__tests__/UpdateEquipment.test.jsx
new file mode 100644
index 00000000000..170df56322c
--- /dev/null
+++ b/src/components/BMDashboard/Equipment/Update/__tests__/UpdateEquipment.test.jsx
@@ -0,0 +1,602 @@
+import { act, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import configureMockStore from 'redux-mock-store';
+import thunk from 'redux-thunk';
+import { MemoryRouter, Route, Router } from 'react-router-dom';
+import { createMemoryHistory } from 'history';
+import UpdateEquipment from '../UpdateEquipment';
+
+const mocks = vi.hoisted(() => ({
+  fetchEquipmentById: vi.fn(),
+  updateEquipment: vi.fn(),
+}));
+
+vi.mock('~/actions/bmdashboard/equipmentActions', () => mocks);
+
+const equipmentId = 'equipment-1';
+const equipmentHistory = {
+  _id: equipmentId,
+  itemType: { name: 'Cordless Drill' },
+  project: { name: 'Community Kitchen' },
+  purchaseStatus: 'Purchase',
+  updateRecord: [
+    {
+      date: '2025-03-05T12:00:00.000Z',
+      condition: 'Working well',
+      lastUsedFor: 'Kitchen - tiling',
+      replacementRequired: 'no',
+    },
+  ],
+  logRecord: [
+    {
+      date: '2025-03-06T12:00:00.000Z',
+      type: 'Check Out',
+      responsibleUser: { firstName: 'Taylor', lastName: 'Volunteer' },
+    },
+  ],
+};
+
+const makeStore = () => {
+  const createStore = configureMockStore([thunk]);
+  return createStore({
+    bmEquipments: { singleEquipment: {} },
+    theme: { darkMode: false },
+  });
+};
+
+const renderForm = () =>
+  render(
+    <Provider store={makeStore()}>
+      <MemoryRouter initialEntries={[`/bmdashboard/tools/${equipmentId}/update`]}>
+        <Route path="/bmdashboard/tools/:equipmentId/update" component={UpdateEquipment} />
+      </MemoryRouter>
+    </Provider>,
+  );
+
+const fillRequiredFields = async () => {
+  await waitFor(() =>
+    expect(screen.getByLabelText(/Who used the tool\/equipment last time/i)).toHaveValue(
+      'Taylor Volunteer',
+    ),
+  );
+  fireEvent.change(screen.getByLabelText(/Status\/Condition Now/i), {
+    target: { value: 'Working well' },
+  });
+  fireEvent.change(screen.getByLabelText(/What was it used for last time/i), {
+    target: { value: 'Kitchen - tiling' },
+  });
+  fireEvent.click(screen.getAllByLabelText('No')[0]);
+};
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.fetchEquipmentById.mockImplementation(() => async () => equipmentHistory);
+  mocks.updateEquipment.mockImplementation((id, data) => async () => ({
+    ...equipmentHistory,
+    updateRecord: [
+      ...equipmentHistory.updateRecord,
+      {
+        date: '2025-03-07T12:00:00.000Z',
+        condition: data.condition,
+        replacementRequired: data.replacementRequired,
+        replacementReason: data.replacementReason,
+      },
+    ],
+  }));
+});
+
+describe('UpdateEquipment history and status form', () => {
+  it('prefills editable defaults and summarizes the latest applicable history', async () => {
+    renderForm();
+
+    await waitFor(() => {
+      expect(screen.getByLabelText(/Who used the tool\/equipment last time/i)).toHaveValue(
+        'Taylor Volunteer',
+      );
+      expect(screen.getByLabelText(/What was it used for last time/i)).toHaveValue(
+        'Kitchen - tiling',
+      );
+    });
+    expect(screen.getByText('Last Update Summary')).toBeInTheDocument();
+    expect(screen.getByText('Mar 5, 2025')).toBeInTheDocument();
+    expect(screen.getAllByText('Working well').length).toBeGreaterThan(0);
+    expect(screen.getAllByText('Taylor Volunteer').length).toBeGreaterThan(0);
+  });
+
+  it('does not overwrite user edits when the history request resolves later', async () => {
+    let resolveHistory;
+    mocks.fetchEquipmentById.mockImplementation(() => () =>
+      new Promise(resolve => {
+        resolveHistory = resolve;
+      }),
+    );
+
+    renderForm();
+    fireEvent.change(screen.getByLabelText(/Who used the tool\/equipment last time/i), {
+      target: { value: 'Jane Doe (Volunteer #1)' },
+    });
+    fireEvent.change(screen.getByLabelText(/What was it used for last time/i), {
+      target: { value: 'Garden - landscaping' },
+    });
+
+    resolveHistory(equipmentHistory);
+
+    await waitFor(() => {
+      expect(screen.getByLabelText(/Who used the tool\/equipment last time/i)).toHaveValue(
+        'Jane Doe (Volunteer #1)',
+      );
+      expect(screen.getByLabelText(/What was it used for last time/i)).toHaveValue(
+        'Garden - landscaping',
+      );
+    });
+  });
+
+  it('requires and submits a replacement reason, then confirms saved response values', async () => {
+    renderForm();
+    await fillRequiredFields();
+
+    fireEvent.click(screen.getByLabelText('Yes'));
+    fireEvent.click(screen.getByRole('button', { name: /Update Status/i }));
+    expect(
+      await within(screen.getByTestId('submit-feedback')).findByRole('alert'),
+    ).toHaveTextContent('Please complete the following required fields: Replacement reason.');
+
+    fireEvent.change(screen.getByLabelText(/Replacement reason/i), {
+      target: { value: 'The drill motor has failed.' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: /Update Status/i }));
+
+    await waitFor(() =>
+      expect(mocks.updateEquipment).toHaveBeenCalledWith(
+        equipmentId,
+        expect.objectContaining({
+          replacementRequired: 'yes',
+          replacementReason: 'The drill motor has failed.',
+        }),
+      ),
+    );
+    expect(await screen.findByText(/Cordless Drill status saved as Good/i)).toBeInTheDocument();
+    expect(screen.getAllByText(/The drill motor has failed/).length).toBeGreaterThan(0);
+  });
+
+  it('shows distinct loading, empty-history and history-error states', async () => {
+    let resolveHistory;
+    mocks.fetchEquipmentById.mockImplementation(() => () =>
+      new Promise(resolve => {
+        resolveHistory = resolve;
+      }),
+    );
+
+    renderForm();
+    expect(screen.getByText(/Loading equipment history/i)).toBeInTheDocument();
+    resolveHistory({ ...equipmentHistory, updateRecord: [], logRecord: [] });
+    expect(await screen.findByText(/No previous status or usage history/i)).toBeInTheDocument();
+  });
+
+  it('shows an explicit message when equipment history cannot be loaded', async () => {
+    mocks.fetchEquipmentById.mockImplementation(() => async () => ({
+      error: new Error('Request failed'),
+    }));
+
+    renderForm();
+
+    expect(await screen.findByText(/Equipment history could not be loaded/i)).toBeInTheDocument();
+  });
+
+  it('tolerates malformed and incomplete history records', async () => {
+    mocks.fetchEquipmentById.mockImplementation(() => async () => ({
+      _id: equipmentId,
+      updateRecord: [null, { date: 'not-a-date', condition: 'Good' }, { condition: 'Good' }],
+      logRecord: [
+        {
+          date: '2025-03-06T12:00:00.000Z',
+          type: 'Check Out',
+          responsibleUser: '507f191e810c19729de860ea',
+        },
+        { type: 'Check Out' },
+      ],
+    }));
+
+    renderForm();
+
+    await waitFor(() => expect(screen.queryByText(/Loading equipment history/i)).toBeNull());
+    expect(screen.getByLabelText(/Who used the tool\/equipment last time/i)).toHaveValue('');
+    expect(screen.getAllByText('Unknown').length).toBeGreaterThan(0);
+  });
+
+  it('shows a failed update as an error without a success confirmation', async () => {
+    mocks.updateEquipment.mockImplementation(() => async () => {
+      throw new Error('Server down');
+    });
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    renderForm();
+    await fillRequiredFields();
+    fireEvent.click(screen.getByRole('button', { name: /Update Status/i }));
+
+    expect(await screen.findByText(/Failed to update equipment/i)).toBeInTheDocument();
+    expect(screen.queryByText(/status saved as/i)).toBeNull();
+  });
+
+  it('ignores a second submit while the first is in flight', async () => {
+    let resolveUpdate;
+    mocks.updateEquipment.mockImplementation(() => () =>
+      new Promise(resolve => {
+        resolveUpdate = resolve;
+      }),
+    );
+
+    renderForm();
+    await fillRequiredFields();
+    const submitButton = screen.getByRole('button', { name: /Update Status/i });
+    fireEvent.submit(submitButton);
+    fireEvent.submit(submitButton);
+
+    expect(mocks.updateEquipment).toHaveBeenCalledTimes(1);
+    resolveUpdate({ ...equipmentHistory });
+    await screen.findByText(/status saved as/i);
+  });
+
+  it('does not let a stale history response populate a different equipment', async () => {
+    const resolvers = {};
+    mocks.fetchEquipmentById.mockImplementation(id => () =>
+      new Promise(resolve => {
+        resolvers[id] = resolve;
+      }),
+    );
+    const routerHistory = createMemoryHistory({ initialEntries: ['/t/equipment-1'] });
+    render(
+      <Provider store={makeStore()}>
+        <Router history={routerHistory}>
+          <Route path="/t/:equipmentId" component={UpdateEquipment} />
+        </Router>
+      </Provider>,
+    );
+    await waitFor(() => expect(resolvers['equipment-1']).toBeDefined());
+
+    act(() => routerHistory.push('/t/equipment-2'));
+    await waitFor(() => expect(resolvers['equipment-2']).toBeDefined());
+
+    await act(async () => {
+      resolvers['equipment-2']({ ...equipmentHistory, _id: 'equipment-2', logRecord: [] });
+      resolvers['equipment-1'](equipmentHistory);
+    });
+    expect(screen.getByLabelText(/Who used the tool\/equipment last time/i)).toHaveValue('');
+  });
+
+  it('keeps image selection preview-only and never claims it was saved', async () => {
+    global.URL.createObjectURL = vi.fn(() => 'blob:preview');
+    global.URL.revokeObjectURL = vi.fn();
+    renderForm();
+    await fillRequiredFields();
+
+    const input = screen.getByLabelText('Upload image files');
+    const file = new File(['x'], 'tool.png', { type: 'image/png' });
+    fireEvent.change(input, { target: { files: [file] } });
+
+    expect(await screen.findByText(/preview only; it will not be saved/i)).toBeInTheDocument();
+    fireEvent.click(screen.getByRole('button', { name: /Update Status/i }));
+    await screen.findByText(/status saved as/i);
+    expect(screen.queryByText(/image.*(saved|uploaded) successfully/i)).toBeNull();
+    expect(mocks.updateEquipment.mock.calls[0][1]).not.toHaveProperty('images');
+  });
+});
+
+describe('UpdateEquipment smart default sources', () => {
+  const userField = () => screen.getByLabelText(/Who used the tool\/equipment last time/i);
+  const purposeField = () => screen.getByLabelText(/What was it used for last time/i);
+  const loadWith = history => {
+    mocks.fetchEquipmentById.mockImplementation(() => async () => ({
+      ...equipmentHistory,
+      ...history,
+    }));
+    return renderForm();
+  };
+
+  it('selects the saved status-update user and purpose when there is no checkout history', async () => {
+    loadWith({
+      logRecord: [],
+      updateRecord: [
+        {
+          date: '2025-03-05T12:00:00.000Z',
+          condition: 'Working well',
+          lastUsedBy: 'Jane Doe (Volunteer #2)',
+          lastUsedFor: 'Garden - landscaping',
+        },
+      ],
+    });
+
+    await waitFor(() => expect(userField()).toHaveValue('Jane Doe (Volunteer #2)'));
+    expect(purposeField()).toHaveValue('Garden - landscaping');
+    expect(screen.getAllByText('Jane Doe (Volunteer #2)').length).toBeGreaterThan(1);
+  });
+
+  it('uses whichever of checkout and saved update is more recent', async () => {
+    const updateRecord = [
+      {
+        date: '2025-03-08T12:00:00.000Z',
+        condition: 'Working well',
+        lastUsedBy: 'Jane Doe (Volunteer #3)',
+      },
+    ];
+    const { unmount } = loadWith({ updateRecord });
+    await waitFor(() => expect(userField()).toHaveValue('Jane Doe (Volunteer #3)'));
+    unmount();
+
+    loadWith({ updateRecord: [{ ...updateRecord[0], date: '2025-03-01T12:00:00.000Z' }] });
+    await waitFor(() => expect(userField()).toHaveValue('Taylor Volunteer'));
+  });
+
+  it('skips unpopulated user ids and falls back to a readable saved name', async () => {
+    loadWith({
+      logRecord: [
+        { date: '2025-03-09T12:00:00.000Z', type: 'Check Out', responsibleUser: 'a'.repeat(24) },
+        {
+          date: '2025-03-10T12:00:00.000Z',
+          type: 'Check In',
+          responsibleUser: { firstName: 'No' },
+        },
+      ],
+      updateRecord: [
+        {
+          date: '2025-03-05T12:00:00.000Z',
+          condition: 'Working well',
+          lastUsedBy: 'Jane Doe (Volunteer #1)',
+        },
+      ],
+    });
+    await waitFor(() => expect(userField()).toHaveValue('Jane Doe (Volunteer #1)'));
+  });
+
+  it('picks the newest record that actually has a purpose, not simply the newest record', async () => {
+    loadWith({
+      updateRecord: [
+        { date: '2025-03-01T12:00:00.000Z', condition: 'Good', lastUsedFor: 'Bathroom - plumbing' },
+        { date: '2025-03-04T12:00:00.000Z', condition: 'Good', lastUsedFor: 'Kitchen - tiling' },
+        { date: '2025-03-09T12:00:00.000Z', condition: 'Needs Repair', lastUsedFor: '  ' },
+      ],
+    });
+    await waitFor(() => expect(purposeField()).toHaveValue('Kitchen - tiling'));
+  });
+
+  it('leaves the user empty when no previous user exists and the purpose empty when none exists', async () => {
+    loadWith({
+      logRecord: [],
+      updateRecord: [{ date: '2025-03-05T12:00:00.000Z', condition: 'Working well' }],
+    });
+    await screen.findByText('Last Update Summary');
+    expect(userField()).toHaveValue('');
+    expect(purposeField()).toHaveValue('');
+  });
+
+  it('shows a previously saved free-text value as a selected option', async () => {
+    loadWith({
+      logRecord: [],
+      updateRecord: [
+        {
+          date: '2025-03-05T12:00:00.000Z',
+          condition: 'Working well',
+          lastUsedBy: 'Morgan Custom',
+          lastUsedFor: 'Roof repair',
+        },
+      ],
+    });
+    await waitFor(() => expect(userField()).toHaveValue('Morgan Custom'));
+    expect(purposeField()).toHaveValue('Roof repair');
+    expect(screen.getByRole('option', { name: 'Morgan Custom', selected: true })).toBeTruthy();
+  });
+
+  it('defaults from the saved record on a fresh load after a successful save, but not after a failed one', async () => {
+    const saved = {
+      ...equipmentHistory,
+      logRecord: [],
+      updateRecord: [
+        {
+          date: '2025-03-07T12:00:00.000Z',
+          condition: 'Working well',
+          lastUsedBy: 'Jane Doe (Volunteer #4)',
+          lastUsedFor: 'Living room - painting',
+          replacementRequired: 'no',
+        },
+      ],
+    };
+    let serverState = { ...equipmentHistory, logRecord: [], updateRecord: [] };
+    mocks.fetchEquipmentById.mockImplementation(() => async () => serverState);
+    mocks.updateEquipment.mockImplementationOnce(() => async () => {
+      throw new Error('Server down');
+    });
+    mocks.updateEquipment.mockImplementationOnce(() => async () => {
+      serverState = saved;
+      return saved;
+    });
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const { unmount: unmountFirst } = renderForm();
+    await screen.findByText('Last Update Summary');
+    fireEvent.change(userField(), { target: { value: 'Jane Doe (Volunteer #4)' } });
+    fireEvent.change(purposeField(), { target: { value: 'Living room - painting' } });
+    fireEvent.change(screen.getByLabelText(/Status\/Condition Now/i), {
+      target: { value: 'Working well' },
+    });
+    fireEvent.click(screen.getAllByLabelText('No')[0]);
+    fireEvent.click(screen.getByRole('button', { name: /Update Status/i }));
+    await screen.findByText(/Failed to update equipment/i);
+    unmountFirst();
+
+    const { unmount: unmountSecond } = renderForm();
+    await screen.findByText('Last Update Summary');
+    expect(userField()).toHaveValue('');
+    expect(purposeField()).toHaveValue('');
+    unmountSecond();
+
+    const { unmount: unmountThird } = renderForm();
+    await screen.findByText('Last Update Summary');
+    fireEvent.change(userField(), { target: { value: 'Jane Doe (Volunteer #4)' } });
+    fireEvent.change(purposeField(), { target: { value: 'Living room - painting' } });
+    fireEvent.change(screen.getByLabelText(/Status\/Condition Now/i), {
+      target: { value: 'Working well' },
+    });
+    fireEvent.click(screen.getAllByLabelText('No')[0]);
+    fireEvent.click(screen.getByRole('button', { name: /Update Status/i }));
+    await screen.findByText(/status saved as/i);
+    unmountThird();
+
+    renderForm();
+    await waitFor(() => expect(userField()).toHaveValue('Jane Doe (Volunteer #4)'));
+    expect(purposeField()).toHaveValue('Living room - painting');
+  });
+
+  describe('submission feedback', () => {
+    const feedback = () => screen.getByTestId('submit-feedback');
+    const submitBtn = () => screen.getByRole('button', { name: /^Update Status$/i });
+
+    it('renders a clean button label with no icon glyphs', () => {
+      renderForm();
+      expect(submitBtn().textContent).toBe('Update Status');
+    });
+
+    it('lists every missing field in one alert placed above the action buttons, with no PUT', async () => {
+      renderForm();
+      fireEvent.click(submitBtn());
+      const alert = await within(feedback()).findByRole('alert');
+      expect(alert).toHaveTextContent(/Please complete the following required fields:/);
+      expect(alert).toHaveTextContent(/Status\/Condition/);
+      expect(alert).toHaveTextContent(/What it was used for last time/);
+      expect(alert).toHaveTextContent(/Replacement required/);
+      expect(within(feedback()).getAllByRole('alert')).toHaveLength(1);
+      expect(
+        alert.compareDocumentPosition(submitBtn()) & Node.DOCUMENT_POSITION_FOLLOWING,
+      ).toBeTruthy();
+      expect(mocks.updateEquipment).not.toHaveBeenCalled();
+    });
+
+    it('shows Saving... while pending and keeps the confirmation after success', async () => {
+      let resolveSave;
+      mocks.updateEquipment.mockImplementation(() => () =>
+        new Promise(resolve => {
+          resolveSave = resolve;
+        }),
+      );
+      renderForm();
+      await fillRequiredFields();
+      fireEvent.click(submitBtn());
+      const saving = await screen.findByRole('button', { name: /Saving\.\.\./ });
+      expect(saving).toBeDisabled();
+      resolveSave({
+        updateRecord: [
+          {
+            date: '2025-04-01T00:00:00.000Z',
+            condition: 'Working well',
+            lastUsedBy: 'Taylor Volunteer',
+            lastUsedFor: 'Kitchen - tiling',
+            replacementRequired: false,
+          },
+        ],
+      });
+      const status = await within(feedback()).findByRole('alert');
+      expect(status).toHaveTextContent(/status saved as/i);
+      expect(status.textContent).not.toMatch(/image.*(uploaded|saved)/i);
+      expect(submitBtn()).toBeEnabled();
+    });
+
+    it.each([
+      ['backend failure', { response: { status: 500, data: { error: 'Boom' } } }, /Boom/],
+      ['network failure', { request: {}, message: 'Network Error' }, /no response from server/i],
+    ])('shows %s near the buttons and preserves entries', async (_n, err, pattern) => {
+      mocks.updateEquipment.mockImplementation(() => () => Promise.reject(err));
+      renderForm();
+      await fillRequiredFields();
+      fireEvent.click(submitBtn());
+      const alert = await within(feedback()).findByRole('alert');
+      expect(alert).toHaveTextContent(pattern);
+      expect(screen.queryByText(/status saved as/i)).toBeNull();
+      expect(screen.getByLabelText(/What was it used for last time/i)).toHaveValue(
+        'Kitchen - tiling',
+      );
+    });
+  });
+
+  describe('status values', () => {
+    const statusField = () => screen.getByLabelText(/Status\/Condition Now/i);
+
+    it.each([
+      ['Working well', 'Good'],
+      ['Broken/Needs repair', 'Needs Repair'],
+      ['Stolen/Lost', 'Out of Order'],
+      ['End of life', 'Out of Order'],
+      ['Returned', 'Good'],
+    ])('keeps the label "%s" and submits the canonical value %s', async (label, stored) => {
+      renderForm();
+      await fillRequiredFields();
+      fireEvent.change(statusField(), { target: { value: label } });
+      fireEvent.click(screen.getByRole('button', { name: /^Update Status$/i }));
+
+      await waitFor(() => expect(mocks.updateEquipment).toHaveBeenCalledTimes(1));
+      expect(mocks.updateEquipment.mock.calls[0][1].condition).toBe(stored);
+      expect(screen.getByRole('option', { name: label })).toBeInTheDocument();
+    });
+
+    it.each([
+      ['Working well', 'Working well'],
+      ['Good', 'Working well'],
+      ['Needs Repair', 'Broken/Needs repair'],
+      ['Broken/Needs repair', 'Broken/Needs repair'],
+      ['Out of Order', 'Stolen/Lost'],
+    ])('preselects the dropdown for a saved %s record', async (saved, label) => {
+      mocks.fetchEquipmentById.mockImplementation(() => async () => ({
+        ...equipmentHistory,
+        updateRecord: [{ date: '2025-03-05T12:00:00.000Z', condition: saved }],
+      }));
+      renderForm();
+      await waitFor(() => expect(statusField()).toHaveValue(label));
+    });
+  });
+
+  describe('details navigation', () => {
+    const setupWithHistory = () => {
+      const routerHistory = createMemoryHistory({
+        initialEntries: [`/bmdashboard/tools/${equipmentId}/update`],
+      });
+      render(
+        <Provider store={makeStore()}>
+          <Router history={routerHistory}>
+            <Route path="/bmdashboard/tools/:equipmentId/update" component={UpdateEquipment} />
+          </Router>
+        </Provider>,
+      );
+      return routerHistory;
+    };
+
+    it('links the success confirmation to the equipment details route with the same id', async () => {
+      const routerHistory = setupWithHistory();
+      await fillRequiredFields();
+      fireEvent.click(screen.getByRole('button', { name: /^Update Status$/i }));
+
+      fireEvent.click(await screen.findByRole('button', { name: /view the equipment details/i }));
+
+      expect(routerHistory.location.pathname).toBe(`/bmdashboard/equipment/${equipmentId}`);
+    });
+
+    it('does not navigate after an unsuccessful submission', async () => {
+      mocks.updateEquipment.mockImplementation(() => () => Promise.reject(new Error('fail')));
+      const routerHistory = setupWithHistory();
+      await fillRequiredFields();
+      fireEvent.click(screen.getByRole('button', { name: /^Update Status$/i }));
+
+      await within(screen.getByTestId('submit-feedback')).findByRole('alert');
+      expect(screen.queryByRole('button', { name: /view the equipment details/i })).toBeNull();
+      expect(routerHistory.location.pathname).toBe(`/bmdashboard/tools/${equipmentId}/update`);
+    });
+  });
+
+  it('applies the scoped navy-on-light-blue summary class regardless of theme', async () => {
+    renderForm();
+    const heading = await screen.findByRole('heading', { name: 'Last Update Summary' });
+    const panel = screen
+      .getAllByRole('alert')
+      .find(el => within(el).queryByText('Last Update Summary'));
+    expect(heading.tagName).toBe('H2');
+    expect(heading.className).toMatch(/lastUpdateSummaryTitle/);
+    expect(panel.className).toMatch(/lastUpdateSummary/);
+  });
+});
diff --git a/src/components/common/DragAndDrop/DragAndDrop.jsx b/src/components/common/DragAndDrop/DragAndDrop.jsx
index 18ce9a5fc2b..a2da544d179 100644
--- a/src/components/common/DragAndDrop/DragAndDrop.jsx
+++ b/src/components/common/DragAndDrop/DragAndDrop.jsx
@@ -5,7 +5,7 @@ import styles from './DragAndDrop.module.css';
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 import { faImage, faUpload } from '@fortawesome/free-solid-svg-icons';
 
-const DragAndDrop = ({ updateUploadedFiles }) => {
+const DragAndDrop = ({ updateUploadedFiles, multiple = true }) => {
   const [dragActive, setDragActive] = useState(false);
   const fileInputRef = useRef(null);
   const dragCounterRef = useRef(0);
@@ -36,10 +36,10 @@ const DragAndDrop = ({ updateUploadedFiles }) => {
       const droppedFiles = e.dataTransfer.files;
       if (droppedFiles && droppedFiles.length > 0) {
         const newFiles = Array.from(droppedFiles);
-        updateUploadedFiles(newFiles);
+        updateUploadedFiles(multiple ? newFiles : newFiles.slice(0, 1));
       }
     },
-    [updateUploadedFiles],
+    [multiple, updateUploadedFiles],
   );
 
   const handleChange = useCallback(
@@ -48,11 +48,11 @@ const DragAndDrop = ({ updateUploadedFiles }) => {
       const selectedFiles = e.target.files;
       if (selectedFiles && selectedFiles.length > 0) {
         const newFiles = Array.from(selectedFiles);
-        updateUploadedFiles(newFiles);
+        updateUploadedFiles(multiple ? newFiles : newFiles.slice(0, 1));
         e.target.value = '';
       }
     },
-    [updateUploadedFiles],
+    [multiple, updateUploadedFiles],
   );
 
   const handleButtonClick = useCallback(() => {
@@ -85,7 +85,7 @@ const DragAndDrop = ({ updateUploadedFiles }) => {
         className={styles.fileUploadInput}
         type="file"
         name="file-upload-input"
-        multiple={true}
+        multiple={multiple}
         accept="image/jpeg, image/jpg, image/png, image/gif, image/webp"
         onChange={handleChange}
         aria-label="Upload image files"
diff --git a/src/components/common/DragAndDrop/__tests__/DragAndDrop.test.jsx b/src/components/common/DragAndDrop/__tests__/DragAndDrop.test.jsx
new file mode 100644
index 00000000000..bd69b951a83
--- /dev/null
+++ b/src/components/common/DragAndDrop/__tests__/DragAndDrop.test.jsx
@@ -0,0 +1,40 @@
+import { fireEvent, render, screen } from '@testing-library/react';
+import DragAndDrop from '../DragAndDrop';
+
+vi.mock('react-redux', () => ({
+  useSelector: selector => selector({ theme: { darkMode: false } }),
+}));
+
+describe('DragAndDrop multiple selection', () => {
+  it('preserves multiple-file selection by default', () => {
+    const updateUploadedFiles = vi.fn();
+    render(<DragAndDrop updateUploadedFiles={updateUploadedFiles} />);
+
+    const input = screen.getByLabelText('Upload image files');
+    expect(input).toHaveAttribute('multiple');
+
+    const files = [
+      new File(['first'], 'first.png', { type: 'image/png' }),
+      new File(['second'], 'second.png', { type: 'image/png' }),
+    ];
+    fireEvent.change(input, { target: { files } });
+
+    expect(updateUploadedFiles).toHaveBeenCalledWith(files);
+  });
+
+  it('limits selection to one file when multiple is disabled', () => {
+    const updateUploadedFiles = vi.fn();
+    render(<DragAndDrop updateUploadedFiles={updateUploadedFiles} multiple={false} />);
+
+    const input = screen.getByLabelText('Upload image files');
+    expect(input).not.toHaveAttribute('multiple');
+
+    const files = [
+      new File(['first'], 'first.png', { type: 'image/png' }),
+      new File(['second'], 'second.png', { type: 'image/png' }),
+    ];
+    fireEvent.change(input, { target: { files } });
+
+    expect(updateUploadedFiles).toHaveBeenCalledWith([files[0]]);
+  });
+});
diff --git a/src/components/common/FilePreview/FilePreview.jsx b/src/components/common/FilePreview/FilePreview.jsx
index 0420344d310..231fe13e4f8 100644
--- a/src/components/common/FilePreview/FilePreview.jsx
+++ b/src/components/common/FilePreview/FilePreview.jsx
@@ -1,6 +1,13 @@
 // FilePreview.jsx
 import PropTypes from 'prop-types';
 import { useCallback } from 'react';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import {
+  faCheckCircle,
+  faExclamationTriangle,
+  faFileImage,
+  faSave,
+} from '@fortawesome/free-solid-svg-icons';
 
 const FilePreview = ({ file, index, darkMode, onRemove }) => {
   const handleRemove = useCallback(() => {
@@ -33,19 +40,19 @@ const FilePreview = ({ file, index, darkMode, onRemove }) => {
         return {
           text: 'Ready for preview',
           color: darkMode ? '#75b798' : '#198754',
-          icon: 'fa-check-circle',
+          icon: faCheckCircle,
         };
       case 'local-only':
         return {
           text: 'Stored locally',
           color: darkMode ? '#6ea8fe' : '#0dcaf0',
-          icon: 'fa-save',
+          icon: faSave,
         };
       case 'not-saved':
         return {
           text: 'Preview only',
           color: darkMode ? '#ffda6a' : '#ffc107',
-          icon: 'fa-exclamation-triangle',
+          icon: faExclamationTriangle,
         };
       default:
         return null;
@@ -97,8 +104,10 @@ const FilePreview = ({ file, index, darkMode, onRemove }) => {
             }}
           >
             <div>
-              <i
-                className="fas fa-file-image fa-2x"
+              <FontAwesomeIcon
+                icon={faFileImage}
+                size="2x"
+                aria-hidden="true"
                 style={{ color: darkMode ? '#adb5bd' : '#6c757d' }}
               />
               <div className="small mt-1" style={{ color: darkMode ? '#adb5bd' : '#6c757d' }}>
@@ -117,8 +126,10 @@ const FilePreview = ({ file, index, darkMode, onRemove }) => {
           }}
         >
           <div>
-            <i
-              className="fas fa-file-image fa-2x"
+            <FontAwesomeIcon
+              icon={faFileImage}
+              size="2x"
+              aria-hidden="true"
               style={{ color: darkMode ? '#adb5bd' : '#6c757d' }}
             />
             <div className="small mt-1" style={{ color: darkMode ? '#adb5bd' : '#6c757d' }}>
@@ -141,7 +152,7 @@ const FilePreview = ({ file, index, darkMode, onRemove }) => {
       {statusInfo && (
         <div className="small">
           <span style={{ color: statusInfo.color }}>
-            <i className={`fas ${statusInfo.icon} me-1`} />
+            <FontAwesomeIcon icon={statusInfo.icon} className="mr-1" aria-hidden="true" />
             {statusInfo.text}
           </span>
         </div>