diff --git a/app-backend/src/controllers/shiftattendance.controller.js b/app-backend/src/controllers/shiftattendance.controller.js
index 4d7ddd810..e9905ffbe 100644
--- a/app-backend/src/controllers/shiftattendance.controller.js
+++ b/app-backend/src/controllers/shiftattendance.controller.js
@@ -1,4 +1,5 @@
 import ShiftAttendance from "../models/ShiftAttendance.js";
+import Shift from "../models/Shift.js";
 
 // Utility: calculate distance using the Haversine formula
 function calculateDistance(lat1, lon1, lat2, lon2) {
@@ -8,8 +9,8 @@ function calculateDistance(lat1, lon1, lat2, lon2) {
   const a =
     Math.sin(dLat / 2) * Math.sin(dLat / 2) +
     Math.cos((lat1 * Math.PI) / 180) *
-      Math.cos((lat2 * Math.PI) / 180) *
-      Math.sin(dLon / 2) * Math.sin(dLon / 2);
+    Math.cos((lat2 * Math.PI) / 180) *
+    Math.sin(dLon / 2) * Math.sin(dLon / 2);
   const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
   return R * c; // distance in km
 }
@@ -19,69 +20,65 @@ export const checkIn = async (req, res) => {
   try {
     const { latitude, longitude } = req.body;
     const { shiftId } = req.params;
-    const guardId = req.user.id;
-
-    // ✅ Validate inputs
-    if (
-      latitude === undefined ||
-      longitude === undefined ||
-      isNaN(latitude) ||
-      isNaN(longitude)
-    ) {
+    const guardId = req.user?._id || req.user?.id;
+
+    if (latitude === undefined || longitude === undefined) {
+      return res.status(400).json({ message: "Invalid location coordinates" });
+    }
+
+    const latNum = Number(latitude);
+    const lngNum = Number(longitude);
+
+    if (!Number.isFinite(latNum) || !Number.isFinite(lngNum)) {
       return res.status(400).json({ message: "Invalid location coordinates" });
     }
 
-    // ✅ Validate shift
-    const shift = await Shift.findById(shiftId).populate("siteId");
+    const shift = await Shift.findById(shiftId);
     if (!shift) {
       return res.status(404).json({ message: "Shift not found" });
     }
 
-    // ✅ Check guard is assigned
+    const siteLatitude = shift.location?.latitude;
+    const siteLongitude = shift.location?.longitude;
+
+    if (!Number.isFinite(siteLatitude) || !Number.isFinite(siteLongitude)) {
+      return res.status(400).json({ message: "Shift location not configured" });
+    }
+
     if (String(shift.assignedGuard) !== String(guardId)) {
       return res.status(403).json({ message: "Not assigned to this shift" });
     }
 
-    // ✅ Prevent duplicate check-in
-    const existing = await ShiftAttendance.findOne({ guardId, shiftId });
+    const existing = await ShiftAttendance.findOne({ guard: guardId, shift: shiftId });
     if (existing) {
       return res.status(400).json({ message: "Already checked in" });
     }
 
-    // ✅ Get real site location
-    const siteLocation = shift.siteId?.location;
-    if (!siteLocation?.latitude || !siteLocation?.longitude) {
-      return res.status(400).json({ message: "Site location not configured" });
+    const distance = calculateDistance(latNum, lngNum, siteLatitude, siteLongitude);
+    if (distance > 0.1) {
+      return res.status(400).json({ message: "Not within shift radius (100m)" });
     }
 
-    const distance = calculateDistance(
-      latitude,
-      longitude,
-      siteLocation.latitude,
-      siteLocation.longitude
-    );
+    const [startHour, startMinute] = String(shift.startTime).split(":").map(Number);
+    const [endHour, endMinute] = String(shift.endTime).split(":").map(Number);
 
-    // ✅ Radius check (100m)
-    if (distance > 0.1) {
-      return res.status(400).json({
-        message: "Not within shift radius (100m)",
-      });
+    const scheduledStart = new Date(shift.date);
+    scheduledStart.setHours(startHour, startMinute, 0, 0);
+
+    const scheduledEnd = new Date(shift.date);
+    scheduledEnd.setHours(endHour, endMinute, 0, 0);
+
+    if (scheduledEnd <= scheduledStart) {
+      scheduledEnd.setDate(scheduledEnd.getDate() + 1);
     }
 
-    // ✅ Save attendance
     const attendance = new ShiftAttendance({
-      guardId,
-      shiftId,
-      checkInTime: new Date(),
-      siteLocation: {
-        type: "Point",
-        coordinates: [siteLocation.longitude, siteLocation.latitude],
-      },
-      checkInLocation: {
-        type: "Point",
-        coordinates: [longitude, latitude],
-      },
-      locationVerified: true,
+      shift: shiftId,
+      guard: guardId,
+      clockIn: new Date(),
+      scheduledStart,
+      scheduledEnd,
+      recordedBy: guardId,
     });
 
     await attendance.save();
@@ -90,7 +87,6 @@ export const checkIn = async (req, res) => {
       message: "Check-in recorded",
       attendance,
     });
-
   } catch (error) {
     return res.status(500).json({ message: error.message });
   }
@@ -99,23 +95,47 @@ export const checkIn = async (req, res) => {
 // POST /api/v1/attendance/checkout/:shiftId
 export const checkOut = async (req, res) => {
   try {
-    console.log("Incoming check-in request:", req.params, req.body);
-
     const { latitude, longitude } = req.body;
     const { shiftId } = req.params;
-    const guardId = req.user.id;
+    const guardId = req.user?._id || req.user?.id;
+
+    if (latitude === undefined || longitude === undefined) {
+      return res.status(400).json({ message: "Invalid location coordinates" });
+    }
 
-    const attendance = await ShiftAttendance.findOne({ guardId, shiftId });
-    if (!attendance)
+    const latNum = Number(latitude);
+    const lngNum = Number(longitude);
+
+    if (!Number.isFinite(latNum) || !Number.isFinite(lngNum)) {
+      return res.status(400).json({ message: "Invalid location coordinates" });
+    }
+
+    const shift = await Shift.findById(shiftId);
+    if (!shift) {
+      return res.status(404).json({ message: "Shift not found" });
+    }
+
+    if (String(shift.assignedGuard) !== String(guardId)) {
+      return res.status(403).json({ message: "Not assigned to this shift" });
+    }
+
+    const attendance = await ShiftAttendance.findOne({ guard: guardId, shift: shiftId });
+    if (!attendance) {
       return res.status(404).json({ message: "No check-in record found" });
+    }
+
+    if (attendance.clockOut) {
+      return res.status(400).json({ message: "Already checked out" });
+    }
+
+    attendance.clockOut = new Date();
+    attendance.recordedBy = guardId;
 
-    attendance.checkOutTime = new Date();
-    attendance.checkOutLocation = { type: "Point", coordinates: [longitude, latitude] };
     await attendance.save();
 
-    res.status(200).json({ message: "Check-out recorded", attendance });
+    return res.status(200).json({ message: "Check-out recorded", attendance });
   } catch (error) {
-    res.status(500).json({ message: error.message });
+    return res.status(500).json({ message: error.message });
   }
 };
 // GET /api/v1/attendance/:userId
@@ -123,8 +143,8 @@ export const getAttendanceByUserId = async (req, res) => {
   try {
     const { userId } = req.params;
 
-    const attendanceRecords = await ShiftAttendance.find({ guardId: userId })
-      .sort({ checkInTime: -1 });
+    const attendanceRecords = await ShiftAttendance.find({ guard: userId })
+      .sort({ clockIn: -1 });
 
     if (!attendanceRecords.length) {
       return res.status(404).json({
diff --git a/app-backend/src/models/ShiftAttendance.js b/app-backend/src/models/ShiftAttendance.js
index 5da3c90c7..64df2064e 100644
--- a/app-backend/src/models/ShiftAttendance.js
+++ b/app-backend/src/models/ShiftAttendance.js
@@ -1,40 +1,112 @@
-import mongoose from "mongoose";
+import mongoose from 'mongoose';
 
-const shiftAttendanceSchema = new mongoose.Schema(
+const { Schema, model } = mongoose;
+
+/**
+ * ShiftAttendance records actual clock-in / clock-out data for a guard on a shift.
+ * Used by the payroll engine to calculate actual hours worked vs. scheduled hours.
+ *
+ * Status lifecycle:
+ *   scheduled  → guard assigned but hasn't clocked in yet
+ *   present    → guard clocked in AND out (hoursWorked computed)
+ *   incomplete → guard clocked in but never clocked out
+ *   absent     → explicitly marked absent (or guard never clocked in)
+ */
+const shiftAttendanceSchema = new Schema(
   {
-    guardId: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "User",
+    shift: {
+      type: Schema.Types.ObjectId,
+      ref: 'Shift',
+      required: true,
+      index: true,
+    },
+
+    guard: {
+      type: Schema.Types.ObjectId,
+      ref: 'User',
+      required: true,
+      index: true,
+    },
+
+    clockIn: {
+      type: Date,
+      default: null,
+    },
+
+    clockOut: {
+      type: Date,
+      default: null,
+    },
+
+    /** Scheduled start (denormalised from Shift for quick queries) */
+    scheduledStart: {
+      type: Date,
       required: true,
     },
-    shiftId: {
-      type: mongoose.Schema.Types.ObjectId,
-      ref: "Shift",
+
+    /** Scheduled end (denormalised from Shift) */
+    scheduledEnd: {
+      type: Date,
       required: true,
     },
-    siteLocation: {
-      type: { type: String, enum: ["Point"], default: "Point" },
-      coordinates: {
-        type: [Number], // [longitude, latitude]
-        required: true,
-      },
+
+    /** Computed hours worked; set automatically in pre-save hook */
+    hoursWorked: {
+      type: Number,
+      default: 0,
+      min: 0,
     },
-    checkInTime: { type: Date, default: null },
-    checkOutTime: { type: Date, default: null },
-    checkInLocation: {
-      type: { type: String, enum: ["Point"], default: "Point" },
-      coordinates: { type: [Number], default: [0, 0] },
+
+    status: {
+      type: String,
+      enum: ['scheduled', 'present', 'incomplete', 'absent'],
+      default: 'scheduled',
+      index: true,
     },
-    checkOutLocation: {
-      type: { type: String, enum: ["Point"], default: "Point" },
-      coordinates: { type: [Number], default: [0, 0] },
+
+    notes: {
+      type: String,
+      trim: true,
+      maxlength: 500,
+    },
+
+    /** Who recorded this attendance (admin/guard) */
+    recordedBy: {
+      type: Schema.Types.ObjectId,
+      ref: 'User',
+      default: null,
     },
-    locationVerified: { type: Boolean, default: false },
   },
   { timestamps: true }
 );
 
-shiftAttendanceSchema.index({ siteLocation: "2dsphere" });
+// Prevent duplicate attendance records per shift/guard pair
+shiftAttendanceSchema.index({ shift: 1, guard: 1 }, { unique: true });
+
+/**
+ * Auto-compute hoursWorked and status based on clockIn / clockOut.
+ */
+shiftAttendanceSchema.pre('save', function (next) {
+  if (this.clockIn && this.clockOut) {
+    if (this.clockOut <= this.clockIn) {
+      return next(new Error('clockOut must be after clockIn'));
+    }
+    const diffMs = this.clockOut.getTime() - this.clockIn.getTime();
+    this.hoursWorked = Math.round((diffMs / (1000 * 60 * 60)) * 100) / 100;
+    this.status = 'present';
+  } else if (this.clockIn && !this.clockOut) {
+    this.status = 'incomplete';
+    // Partial hours from clock-in to now (capped at scheduled end)
+    const now = new Date();
+    const cap = this.scheduledEnd || now;
+    const diffMs = Math.min(now.getTime(), cap.getTime()) - this.clockIn.getTime();
+    this.hoursWorked = diffMs > 0 ? Math.round((diffMs / (1000 * 60 * 60)) * 100) / 100 : 0;
+  } else if (!this.clockIn) {
+    this.status = 'absent';
+    this.hoursWorked = 0;
+  }
+  next();
+});
 
-const ShiftAttendance = mongoose.model("ShiftAttendance", shiftAttendanceSchema);
-export default ShiftAttendance;
+const ShiftAttendance = model('ShiftAttendance', shiftAttendanceSchema);
+export default ShiftAttendance;
\ No newline at end of file
diff --git a/guard_app/package-lock.json b/guard_app/package-lock.json
index cf1fae5f2..d481e4a2e 100644
--- a/guard_app/package-lock.json
+++ b/guard_app/package-lock.json
@@ -3037,7 +3037,7 @@
       "version": "19.1.17",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.1.17.tgz",
       "integrity": "sha512-Qec1E3mhALmaspIrhWt9jkQMNdw6bReVu64mjvhbhq2NFPftLPVr+l1SZgmw/66WwBNpDh7ao5AT6gF5v41PFA==",
-      "devOptional": true,
+      "dev": true,
       "dependencies": {
         "csstype": "^3.0.2"
       }
@@ -4892,7 +4892,7 @@
       "version": "3.2.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
       "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
-      "devOptional": true
+      "dev": true
     },
     "node_modules/data-view-buffer": {
       "version": "1.0.2",
@@ -12261,7 +12261,7 @@
       "version": "5.9.3",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
       "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
-      "devOptional": true,
+      "dev": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
diff --git a/guard_app/src/api/attendance.ts b/guard_app/src/api/attendance.ts
index e96bc0d97..1109ecd10 100644
--- a/guard_app/src/api/attendance.ts
+++ b/guard_app/src/api/attendance.ts
@@ -5,6 +5,14 @@ import http from '../lib/http';
 
 export type Attendance = {
   _id: string;
+  shift: string | { _id: string };
+  guard: string | { _id: string };
+  clockIn?: string | null;
+  clockOut?: string | null;
+  scheduledStart?: string;
+  scheduledEnd?: string;
+  hoursWorked?: number;
+  status?: string;
   guardId: string;
   shiftId: string | any;
   checkInTime?: string | null;
diff --git a/guard_app/src/components/functions/formatAttendanceTime.ts b/guard_app/src/components/functions/formatAttendanceTime.ts
new file mode 100644
index 000000000..5550b09fe
--- /dev/null
+++ b/guard_app/src/components/functions/formatAttendanceTime.ts
@@ -0,0 +1,11 @@
+export function formatAttendanceTime(value?: string) {
+  if (!value) return 'N/A';
+
+  return new Date(value).toLocaleString('en-AU', {
+    day: '2-digit',
+    month: 'short',
+    year: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+  });
+}
diff --git a/guard_app/src/components/modal/ShiftDetailsModal.tsx b/guard_app/src/components/modal/ShiftDetailsModal.tsx
index e868f0eb5..3bf282e7d 100644
--- a/guard_app/src/components/modal/ShiftDetailsModal.tsx
+++ b/guard_app/src/components/modal/ShiftDetailsModal.tsx
@@ -7,6 +7,7 @@ import ShiftRequestModal from './ShiftRequestModal';
 
 import type { AllShift, AppliedShift, CompletedShift } from '../../models/Shifts';
 import type { AppColors } from '../../theme/colors';
+import { formatAttendanceTime } from '../functions/formatAttendanceTime';
 
 type Props = {
   shift: AppliedShift | CompletedShift | AllShift | null;
@@ -32,6 +33,8 @@ function ShiftDetailsModal({ shift, visible, onClose, colors }: Props) {
           ? colors.primary
           : colors.muted;
 
+  const hasAttendance = Boolean(shift.attendance?.checkInTime || shift.attendance?.checkOutTime);
+
   return (
     <Modal visible={visible} transparent animationType="fade" onRequestClose={onClose}>
       <Pressable style={s.modalOverlay} onPress={onClose}>
@@ -100,6 +103,29 @@ function ShiftDetailsModal({ shift, visible, onClose, colors }: Props) {
                 </View>
               </View>
             </View>
+            {hasAttendance ? (
+              <View style={s.modalRequirements}>
+                <Text style={s.modalRequirementsTitle}>Attendance History</Text>
+
+                {shift.attendance?.checkInTime ? (
+                  <View style={s.modalDetail}>
+                    <Text style={s.modalLabel}>✅ Checked In</Text>
+                    <Text style={s.modalValue}>
+                      {formatAttendanceTime(shift.attendance.checkInTime)}
+                    </Text>
+                  </View>
+                ) : null}
+
+                {shift.attendance?.checkOutTime ? (
+                  <View style={s.modalDetail}>
+                    <Text style={s.modalLabel}>✅ Checked Out</Text>
+                    <Text style={s.modalValue}>
+                      {formatAttendanceTime(shift.attendance.checkOutTime)}
+                    </Text>
+                  </View>
+                ) : null}
+              </View>
+            ) : null}
           </View>
         </Pressable>
       </Pressable>
diff --git a/guard_app/src/models/Shifts.ts b/guard_app/src/models/Shifts.ts
index 6699d56db..d0f5b5da2 100644
--- a/guard_app/src/models/Shifts.ts
+++ b/guard_app/src/models/Shifts.ts
@@ -8,6 +8,10 @@ export type AppliedShift = {
   date: string;
   time: string;
   status?: 'Pending' | 'Confirmed' | 'Rejected';
+  attendance?: {
+    checkInTime?: string;
+    checkOutTime?: string;
+  };
 };
 
 export type CompletedShift = {
@@ -21,6 +25,10 @@ export type CompletedShift = {
   rated: boolean;
   rating: number;
   status?: 'Completed';
+  attendance?: {
+    checkInTime?: string;
+    checkOutTime?: string;
+  };
 };
 
 export type AllShift = {
@@ -32,6 +40,10 @@ export type AllShift = {
   date: string;
   time: string;
   status?: 'Available' | 'Pending' | 'Confirmed';
+  attendance?: {
+    checkInTime?: string;
+    checkOutTime?: string;
+  };
 };
 
 export type ShiftCardItem = AppliedShift | CompletedShift | AllShift;
diff --git a/guard_app/src/screen/HomeScreen.tsx b/guard_app/src/screen/HomeScreen.tsx
index 350e7c240..437f9d177 100644
--- a/guard_app/src/screen/HomeScreen.tsx
+++ b/guard_app/src/screen/HomeScreen.tsx
@@ -22,6 +22,8 @@ import http from '../lib/http';
 import { RootStackParamList } from '../navigation/AppNavigator';
 import { useAppTheme } from '../theme';
 import { AppColors } from '../theme/colors';
+import { showLocalNotification } from '../utils/notificationHelpers';
+import { LocalStorage } from '../lib/localStorage';
 
 type Nav = NativeStackNavigationProp<RootStackParamList>;
 
@@ -132,18 +134,6 @@ export default function HomeScreen() {
       headerTintColor: colors.white,
       headerRight: () => (
         <View style={{ flexDirection: 'row', alignItems: 'center' }}>
-          <TouchableOpacity
-            onPress={() => navigation.navigate('IncidentReports')}
-            style={{ paddingHorizontal: 8 }}
-          >
-            <Ionicons name="alert-circle-outline" size={22} color={colors.white} />
-          </TouchableOpacity>
-          <TouchableOpacity
-            onPress={() => navigation.navigate('Payroll')}
-            style={{ paddingHorizontal: 8 }}
-          >
-            <Ionicons name="card-outline" size={22} color={colors.white} />
-          </TouchableOpacity>
           <TouchableOpacity
             onPress={() => navigation.navigate('Messages')}
             style={{ paddingHorizontal: 8 }}
@@ -209,6 +199,8 @@ export default function HomeScreen() {
     setRefreshing(true);
     await load();
     setRefreshing(false);
+    const token = await LocalStorage.getToken();
+    console.log('Refreshed home data. Current token:', token);
   };
 
   return (
@@ -320,6 +312,16 @@ export default function HomeScreen() {
               <Text style={styles.emptyText}>{t('home.noUpcoming')}</Text>
             )}
           </View>
+
+          <View style={{ justifyContent: 'center', padding: 20 }}>
+            <Button
+              title={t('homeExtras.testNotif')}
+              onPress={async () => {
+                await showLocalNotification(t('homeExtras.notifTitle'), t('homeExtras.notifBody'));
+              }}
+            />
+          </View>
+
           <View style={styles.spacer} />
         </View>
       </ScrollView>
diff --git a/guard_app/src/screen/ShiftDetailsScreen.tsx b/guard_app/src/screen/ShiftDetailsScreen.tsx
index f0977d69b..d52f3f1c7 100644
--- a/guard_app/src/screen/ShiftDetailsScreen.tsx
+++ b/guard_app/src/screen/ShiftDetailsScreen.tsx
@@ -12,6 +12,7 @@ import { getAttendanceForShift, setAttendanceForShift } from '../lib/attendances
 import { LocalStorage } from '../lib/localStorage';
 import { useAppTheme } from '../theme';
 import { formatDate } from '../utils/date';
+import { formatAttendanceTime } from '../components/functions/formatAttendanceTime';
 
 import type { ShiftDto } from '../api/shifts';
 import type { RootStackParamList } from '../navigation/AppNavigator';
@@ -25,6 +26,11 @@ type AttendanceState = {
   checkOutTime?: string;
 };
 
+type AttendanceHistoryItem = {
+  label: string;
+  value: string;
+};
+
 type ErrorState = {
   title: string;
   message: string;
@@ -39,16 +45,6 @@ function StatusBadge({ status, color }: { status: string; color: string }) {
   return <Text style={[stylesInline.statusBadge, { color }]}>{status.toUpperCase()}</Text>;
 }
 
-const normalizeAttendance = (
-  attendance?: {
-    checkInTime?: string | null;
-    checkOutTime?: string | null;
-  } | null,
-): AttendanceState => ({
-  checkInTime: attendance?.checkInTime ?? undefined,
-  checkOutTime: attendance?.checkOutTime ?? undefined,
-});
-
 function formatLocalDateKey(date: Date) {
   const year = date.getFullYear();
   const month = `${date.getMonth() + 1}`.padStart(2, '0');
@@ -124,31 +120,38 @@ export default function ShiftDetailsScreen() {
   useEffect(() => {
     (async () => {
       const storedAttendance = await getAttendanceForShift(shift._id);
-      if (storedAttendance?.checkInTime) {
-        setAttendance(normalizeAttendance(storedAttendance));
-        return;
+
+      if (storedAttendance?.checkInTime || storedAttendance?.checkOutTime) {
+        setAttendance(storedAttendance);
       }
 
       try {
         const token = await LocalStorage.getToken();
         if (!token) return;
+
         const payload = JSON.parse(atob(token.split('.')[1]));
         const userId = payload.id ?? payload._id ?? payload.sub;
         if (!userId) return;
 
         const records = await getUserAttendance(userId);
-        const match = records.find(
-          (r) =>
-            String(r.shiftId === 'object' ? (r.shiftId as any)?._id : r.shiftId) ===
-              String(shift._id) || String(r.shiftId) === String(shift._id),
-        );
-        if (match?.checkInTime) {
-          const synced = normalizeAttendance(match);
+
+        const match = records.find((record) => {
+          const recordShiftId = typeof record.shift === 'object' ? record.shift?._id : record.shift;
+
+          return String(recordShiftId) === String(shift._id);
+        });
+
+        if (match?.clockIn || match?.clockOut) {
+          const synced: AttendanceState = {
+            checkInTime: match.clockIn ?? storedAttendance?.checkInTime,
+            checkOutTime: match.clockOut ?? storedAttendance?.checkOutTime,
+          };
+
           setAttendance(synced);
-          setAttendanceForShift(shift._id, synced).catch(() => {});
+          await setAttendanceForShift(shift._id, synced);
         }
-      } catch {
-        // server fetch failed, stay with null
+      } catch (error) {
+        console.log('Failed to load attendance history:', error);
       }
     })();
   }, [shift._id]);
@@ -244,10 +247,10 @@ export default function ShiftDetailsScreen() {
         console.log('➡️ checkIn request for shift:', shift._id);
         const res = await checkIn(shift._id, loc);
 
-        const next: AttendanceState = normalizeAttendance({
-          checkInTime: res.attendance?.checkInTime ?? new Date().toISOString(),
-          checkOutTime: undefined,
-        });
+        const next: AttendanceState = {
+          checkInTime: res.attendance?.clockIn ?? new Date().toISOString(),
+          checkOutTime: res.attendance?.clockOut ?? undefined,
+        };
 
         setAttendance(next);
         setAttendanceForShift(shift._id, next).catch(() => {});
@@ -267,10 +270,10 @@ export default function ShiftDetailsScreen() {
         console.log('➡️ checkOut request for shift:', shift._id);
         const res = await checkOut(shift._id, loc);
 
-        const next: AttendanceState = normalizeAttendance({
-          checkInTime: res.attendance?.checkInTime ?? attendance?.checkInTime,
-          checkOutTime: res.attendance?.checkOutTime ?? new Date().toISOString(),
-        });
+        const next: AttendanceState = {
+          checkInTime: res.attendance?.clockIn ?? attendance?.checkInTime,
+          checkOutTime: res.attendance?.clockOut ?? new Date().toISOString(),
+        };
 
         setAttendance(next);
         setAttendanceForShift(shift._id, next).catch(() => {});
@@ -356,6 +359,17 @@ export default function ShiftDetailsScreen() {
   const showCheckIn = canDoAttendance && !hasCheckedIn;
   const showCheckOut = canDoAttendance && hasCheckedIn && !hasCheckedOut;
 
+  const shouldShowAttendanceHistory = shift.status === 'completed' || hasCheckedIn;
+
+  const attendanceHistory: AttendanceHistoryItem[] = [
+    ...(attendance?.checkInTime
+      ? [{ label: '✅ Checked In', value: formatAttendanceTime(attendance.checkInTime) }]
+      : []),
+    ...(attendance?.checkOutTime
+      ? [{ label: '✅ Checked Out', value: formatAttendanceTime(attendance.checkOutTime) }]
+      : []),
+  ];
+
   const handleMessageEmployer = () => {
     const employerId = shift.createdBy?._id;
 
@@ -414,13 +428,46 @@ export default function ShiftDetailsScreen() {
             <StatusBadge status={shift.status ?? 'open'} color={statusColor} />
           </View>
 
-          {attendance?.checkInTime ? (
-            <Text style={s.metaText}>✅ Checked in: {attendance.checkInTime}</Text>
-          ) : null}
+          <View style={s.section}>
+            <Text style={s.sectionTitle}>Location Details</Text>
 
-          {attendance?.checkOutTime ? (
-            <Text style={s.metaText}>✅ Checked out: {attendance.checkOutTime}</Text>
-          ) : null}
+            <View style={s.infoRow}>
+              <Text style={s.infoLabel}>Street</Text>
+              <Text style={s.infoValue}>{shift.location?.street ?? 'N/A'}</Text>
+            </View>
+
+            <View style={s.infoRow}>
+              <Text style={s.infoLabel}>Suburb</Text>
+              <Text style={s.infoValue}>{shift.location?.suburb ?? 'N/A'}</Text>
+            </View>
+
+            <View style={s.infoRow}>
+              <Text style={s.infoLabel}>State</Text>
+              <Text style={s.infoValue}>{shift.location?.state ?? 'N/A'}</Text>
+            </View>
+
+            <View style={s.infoRow}>
+              <Text style={s.infoLabel}>Postcode</Text>
+              <Text style={s.infoValue}>{shift.location?.postcode ?? 'N/A'}</Text>
+            </View>
+          </View>
+
+          {shouldShowAttendanceHistory && (
+            <View style={s.section}>
+              <Text style={s.sectionTitle}>Attendance History</Text>
+
+              {attendanceHistory.length > 0 ? (
+                attendanceHistory.map((item, index) => (
+                  <View key={index} style={s.historyItem}>
+                    <Text style={s.historyLabel}>{item.label}</Text>
+                    <Text style={s.historyValue}>{item.value}</Text>
+                  </View>
+                ))
+              ) : (
+                <Text style={s.emptyHistory}>No attendance history available</Text>
+              )}
+            </View>
+          )}
         </View>
 
         <View style={s.actions}>
@@ -580,4 +627,52 @@ const getStyles = (colors: AppColors) =>
     hintStrong: {
       fontWeight: '700',
     },
+    section: {
+      marginTop: 18,
+      paddingTop: 16,
+      borderTopWidth: 1,
+      borderTopColor: colors.border,
+    },
+    sectionTitle: {
+      fontSize: 16,
+      fontWeight: '700',
+      color: colors.text,
+      marginBottom: 12,
+    },
+    infoRow: {
+      flexDirection: 'row',
+      justifyContent: 'space-between',
+      marginBottom: 10,
+    },
+    infoLabel: {
+      fontSize: 14,
+      color: colors.muted,
+    },
+    infoValue: {
+      fontSize: 14,
+      color: colors.text,
+      fontWeight: '500',
+      maxWidth: '65%',
+      textAlign: 'right',
+    },
+    historyItem: {
+      backgroundColor: colors.primarySoft,
+      borderRadius: 10,
+      padding: 12,
+      marginBottom: 10,
+    },
+    historyLabel: {
+      fontSize: 13,
+      color: colors.muted,
+      marginBottom: 4,
+    },
+    historyValue: {
+      fontSize: 14,
+      color: colors.text,
+      fontWeight: '700',
+    },
+    emptyHistory: {
+      fontSize: 14,
+      color: colors.muted,
+    },
   });
diff --git a/guard_app/src/screen/ShiftsScreen.tsx b/guard_app/src/screen/ShiftsScreen.tsx
index 25651acbf..8e7131832 100644
--- a/guard_app/src/screen/ShiftsScreen.tsx
+++ b/guard_app/src/screen/ShiftsScreen.tsx
@@ -22,6 +22,7 @@ import ShiftCard from '../components/card/ShiftCard';
 import ShiftDetailsModal from '../components/modal/ShiftDetailsModal';
 import ViewToggle from '../components/toggle/ViewToggle';
 import { useAppTheme } from '../theme';
+import { getUserAttendance } from '../api/attendance';
 
 import type { AllShift, AppliedShift, CompletedShift } from '../models/Shifts';
 import type { AppColors } from '../theme/colors';
@@ -32,7 +33,11 @@ type Props = {
   navigation: any;
 };
 
-function mapMineShifts(shifts: ShiftDto[], myUid: string): AppliedShift[] {
+function mapMineShifts(
+  shifts: ShiftDto[],
+  myUid: string,
+  attendanceRecords: any[] = [],
+): AppliedShift[] {
   return shifts
     .filter((s) => s.status !== 'completed')
     .map((s) => {
@@ -43,6 +48,12 @@ function mapMineShifts(shifts: ShiftDto[], myUid: string): AppliedShift[] {
         ? s.applicants.map((a) => (typeof a === 'object' ? a._id : String(a)))
         : [];
 
+      const attendance = attendanceRecords.find((record) => {
+        const recordShiftId = typeof record.shift === 'object' ? record.shift?._id : record.shift;
+
+        return String(recordShiftId) === String(s._id);
+      });
+
       let status: AppliedShift['status'];
       if (s.status === 'assigned' && acceptedId === myUid) status = 'Confirmed';
       else if (s.status === 'assigned' && applicants.includes(myUid)) status = 'Rejected';
@@ -57,24 +68,44 @@ function mapMineShifts(shifts: ShiftDto[], myUid: string): AppliedShift[] {
         date: s.date,
         time: `${s.startTime} - ${s.endTime}`,
         status,
+        attendance: attendance
+          ? {
+              checkInTime: attendance.clockIn ?? undefined,
+              checkOutTime: attendance.clockOut ?? undefined,
+            }
+          : undefined,
       };
     });
 }
 
-function mapCompleted(shifts: ShiftDto[]): CompletedShift[] {
+function mapCompleted(shifts: ShiftDto[], attendanceRecords: any[] = []): CompletedShift[] {
   return shifts
     .filter((s) => s.status === 'completed')
-    .map((s) => ({
-      id: s._id,
-      title: s.title,
-      company: s.createdBy?.company ?? '—',
-      site: s.location ? `${s.location.suburb ?? ''} ${s.location.state ?? ''}`.trim() : '—',
-      rate: typeof s.payRate === 'number' ? `$${s.payRate}/hour` : '$—',
-      date: s.date,
-      time: `${s.startTime} - ${s.endTime}`,
-      rated: false,
-      rating: 0,
-    }));
+    .map((s) => {
+      const attendance = attendanceRecords.find((record) => {
+        const recordShiftId = typeof record.shift === 'object' ? record.shift?._id : record.shift;
+
+        return String(recordShiftId) === String(s._id);
+      });
+
+      return {
+        id: s._id,
+        title: s.title,
+        company: s.createdBy?.company ?? '—',
+        site: s.location ? `${s.location.suburb ?? ''} ${s.location.state ?? ''}`.trim() : '—',
+        rate: typeof s.payRate === 'number' ? `$${s.payRate}/hour` : '$—',
+        date: s.date,
+        time: `${s.startTime} - ${s.endTime}`,
+        rated: false,
+        rating: 0,
+        attendance: attendance
+          ? {
+              checkInTime: attendance.clockIn ?? undefined,
+              checkOutTime: attendance.clockOut ?? undefined,
+            }
+          : undefined,
+      };
+    });
 }
 
 function mapAllShifts(shifts: ShiftDto[], myUid: string): AllShift[] {
@@ -236,8 +267,9 @@ function AppliedTab({ navigation }: Props) {
         setRows([]);
         return;
       }
-      const mine = await myShifts();
-      setRows(mapMineShifts(mine, myUid));
+      const [mine, attendanceRecords] = await Promise.all([myShifts(), getUserAttendance(myUid)]);
+
+      setRows(mapMineShifts(mine, myUid, attendanceRecords));
     } finally {
       setLoading(false);
     }
@@ -320,8 +352,16 @@ function CompletedTab({ navigation }: Props) {
   const fetchData = useCallback(async () => {
     try {
       setLoading(true);
-      const resp = await myShifts('past');
-      setRows(mapCompleted(resp));
+
+      const me = await getMe();
+      const myUid = me?._id ?? me?.id;
+
+      const [resp, attendanceRecords] = await Promise.all([
+        myShifts('past'),
+        myUid ? getUserAttendance(myUid) : Promise.resolve([]),
+      ]);
+
+      setRows(mapCompleted(resp, attendanceRecords));
     } finally {
       setLoading(false);
     }