diff --git a/src/app/debug/bookings/BookingDebugPage.module.scss b/src/app/debug/bookings/BookingDebugPage.module.scss
index 46e137b..bb97448 100644
--- a/src/app/debug/bookings/BookingDebugPage.module.scss
+++ b/src/app/debug/bookings/BookingDebugPage.module.scss
@@ -25,3 +25,50 @@
   overflow-x: auto;
   margin-top: 1rem;
 }
+
+.debugOutput {
+  grid-column: 1 / -1;
+  background: #1a1a2e;
+  color: #eee;
+  padding: 1rem;
+  border-radius: 8px;
+  border-left: 4px solid #6366f1;
+
+  h4 {
+    margin: 0 0 0.75rem;
+    font-size: 0.95rem;
+  }
+
+  pre {
+    margin: 0;
+    white-space: pre-wrap;
+    font-size: 0.85rem;
+  }
+}
+
+.errorMessage {
+  color: #ef4444;
+}
+
+.bookedSlotsTable {
+  grid-column: 1 / -1;
+  background: #1a1a2e;
+  color: #eee;
+  padding: 1rem;
+  border-radius: 8px;
+  border-left: 4px solid #22c55e;
+
+  h4 {
+    margin: 0 0 0.75rem;
+    font-size: 0.95rem;
+  }
+}
+
+.bookedSlotsTableBody {
+  th,
+  td {
+    background: #252540 !important;
+    color: #eee !important;
+    border-color: #3f3f5a !important;
+  }
+}
diff --git a/src/app/debug/bookings/page.tsx b/src/app/debug/bookings/page.tsx
index e823f7a..ec9a3a3 100644
--- a/src/app/debug/bookings/page.tsx
+++ b/src/app/debug/bookings/page.tsx
@@ -1,26 +1,155 @@
 "use client";
 
-import { Button, Divider, Group, Select, Textarea, TextInput } from "@mantine/core";
+import {
+  Alert,
+  Button,
+  Divider,
+  Group,
+  Select,
+  Table,
+  Text,
+  Textarea,
+  TextInput,
+} from "@mantine/core";
+import { DateInput, TimeInput } from "@mantine/dates";
 import { useForm } from "@mantine/form";
 import { notifications } from "@mantine/notifications";
-import { useState } from "react";
+import { useEffect, useMemo, useState } from "react";
 import { api } from "@/trpc/react";
 import { ALL_BOOKING_STATUSES, BookingStatus, type BookingStatusValue } from "@/types/types";
 import styles from "./BookingDebugPage.module.scss";
 
+/** Returns true if end is after start (or invalid); used for form validation. */
+function isEndAfterStart(start: string, end: string) {
+  const a = new Date(start).getTime();
+  const b = new Date(end).getTime();
+  if (Number.isNaN(a) || Number.isNaN(b)) return true; // let backend/zod handle invalid formats
+  return b > a;
+}
+
+/** Formats start and end as a time range string in UTC (e.g. 9:00 AM – 10:30 AM). */
+function formatTimeSlot(startTime: string, endTime: string): string {
+  // Format in UTC to match stored booking times (e.g. "09:00:00+00" -> "9:00 AM")
+  const opts: Intl.DateTimeFormatOptions = {
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+    timeZone: "UTC",
+  };
+  const start = new Date(startTime).toLocaleTimeString("en-US", opts);
+  const end = new Date(endTime).toLocaleTimeString("en-US", opts);
+  return `${start} – ${end}`;
+}
+
+/** Example pre-filled booking for testing. agencyId must be a valid user.id; set dynamically from getCurrentUser. */
+const EXAMPLE_BOOKING = {
+  title: "Test Example",
+  pickupAddress: "The Inn from the Cold, 110 11 Ave SE, Calgary, AB",
+  destinationAddress: "Sheldon M. Chumir Health Centre, 1213 4 St SW, Calgary, AB",
+  passengerInfo: "John Smith",
+  phoneNumber: "+1 (403) 760-9834",
+  purpose: "Medical appointment",
+  start: "2026-02-12T15:00:00.000Z", // Feb 12, 2026 3:00 PM UTC
+};
+
+/** Returns true if the booking overlaps the given UTC day (day boundaries in UTC). */
+function bookingOverlapsDay(booking: { startTime: string; endTime: string }, day: Date): boolean {
+  const y = day.getUTCFullYear();
+  const m = day.getUTCMonth();
+  const d = day.getUTCDate();
+  const dStart = Date.UTC(y, m, d, 0, 0, 0, 0);
+  const dEnd = Date.UTC(y, m, d, 23, 59, 59, 999);
+
+  const start = new Date(booking.startTime).getTime();
+  const end = new Date(booking.endTime).getTime();
+
+  return start < dEnd && end > dStart;
+}
+
+type BookingForSchedule = {
+  id: number;
+  driverId: string | null;
+  status: string;
+  startTime: string;
+  endTime: string;
+  title: string;
+};
+
+/** Table of a driver's bookings for the selected day; shows time slot and title. */
+function DriverScheduleTable({
+  bookings,
+  day,
+  driverId,
+}: {
+  bookings: BookingForSchedule[];
+  day: Date | null;
+  driverId: string;
+}) {
+  if (!day || !driverId) return null;
+  const bookedSlots = bookings
+    .filter(
+      (b) => b.driverId === driverId && b.status !== "cancelled" && bookingOverlapsDay(b, day),
+    )
+    .sort((a, b) => new Date(a.startTime).getTime() - new Date(b.startTime).getTime());
+
+  if (bookedSlots.length === 0) {
+    return (
+      <Text size="sm" c="dimmed">
+        No bookings this day – driver available all day
+      </Text>
+    );
+  }
+
+  return (
+    <Table withTableBorder withColumnBorders className={styles.bookedSlotsTableBody}>
+      <Table.Thead>
+        <Table.Tr>
+          <Table.Th>Time slot</Table.Th>
+          <Table.Th>Booking</Table.Th>
+        </Table.Tr>
+      </Table.Thead>
+      <Table.Tbody>
+        {bookedSlots.map((b) => (
+          <Table.Tr key={b.id}>
+            <Table.Td>{formatTimeSlot(b.startTime, b.endTime)}</Table.Td>
+            <Table.Td>
+              Booking #{b.id} – {b.title}
+            </Table.Td>
+          </Table.Tr>
+        ))}
+      </Table.Tbody>
+    </Table>
+  );
+}
+
+/** Debug page for creating/editing bookings and viewing driver availability. */
 export default function BookingDebugPage() {
   const [bookingId, setBookingId] = useState<number>(1);
 
+  // Day picker for driver availability (date-only)
+  const [selectedDay, setSelectedDay] = useState<Date | null>(() => {
+    const d = new Date(EXAMPLE_BOOKING.start);
+    return new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+  });
+
+  // Start time of day only (HH:mm) - day comes from selectedDay
+  const [startTimeOfDay, setStartTimeOfDay] = useState<string>(() => {
+    const d = new Date(EXAMPLE_BOOKING.start);
+    const h = d.getUTCHours().toString().padStart(2, "0");
+    const m = d.getUTCMinutes().toString().padStart(2, "0");
+    return `${h}:${m}`;
+  });
   const form = useForm({
     initialValues: {
-      title: "",
-      pickupAddress: "",
-      destinationAddress: "",
-      passengerInfo: "",
-      start: "",
-      end: "",
-      agencyId: "",
-      purpose: "",
+      title: EXAMPLE_BOOKING.title,
+      pickupAddress: EXAMPLE_BOOKING.pickupAddress,
+      destinationAddress: EXAMPLE_BOOKING.destinationAddress,
+      passengerInfo: EXAMPLE_BOOKING.passengerInfo,
+      phoneNumber: EXAMPLE_BOOKING.phoneNumber ?? "",
+      start: EXAMPLE_BOOKING.start, // will be kept in sync with picker (string)
+      end: "", // will be kept in sync with picker (string), auto-calculated
+      agencyId: "", // set from getCurrentUser (must be valid user.id for FK)
+      purpose: EXAMPLE_BOOKING.purpose,
       driverId: "",
       status: BookingStatus.INCOMPLETE as BookingStatusValue,
     },
@@ -39,11 +168,97 @@ export default function BookingDebugPage() {
 
   const bookingQuery = api.bookings.getById.useQuery({ id: bookingId }, { enabled: false });
 
+  const canShowDriverAvailability = !!selectedDay && !!form.values.driverId?.trim();
+
   const allBookingsQuery = api.bookings.getAll.useQuery(undefined, {
-    enabled: false,
+    enabled: true, // fetch on load for both driver availability table and Fetch All
     staleTime: 0,
   });
 
+  const listDriversQuery = api.bookings.listDrivers.useQuery();
+  const currentUserQuery = api.bookings.getCurrentUser.useQuery();
+
+  // Set agencyId from current user so it references a valid user (fixes FK constraint)
+  useEffect(() => {
+    if (currentUserQuery.data && !form.values.agencyId) {
+      form.setFieldValue("agencyId", currentUserQuery.data.id);
+    }
+  }, [currentUserQuery.data, form.setFieldValue, form.values.agencyId]);
+
+  const driverOptions = useMemo(
+    () =>
+      (listDriversQuery.data ?? []).map((d) => ({
+        value: d.id,
+        label: "email" in d && d.email != null ? `${d.name} (${d.email})` : d.name,
+      })),
+    [listDriversQuery.data],
+  );
+
+  // Pre-select first driver when options load (for example pre-fill)
+  useEffect(() => {
+    if (driverOptions.length > 0 && !form.values.driverId) {
+      form.setFieldValue("driverId", driverOptions[0]?.value ?? "");
+    }
+  }, [driverOptions, form.setFieldValue, form.values.driverId]);
+
+  // Compute full start ISO from selectedDay + startTimeOfDay (naive UTC to match booking storage)
+  const computedStart = useMemo(() => {
+    const day = selectedDay;
+    const time = startTimeOfDay;
+    if (!day || !time) return "";
+    const parts = time.split(":").map(Number);
+    const [h, m] = parts;
+    if (h == null || m == null || Number.isNaN(h) || Number.isNaN(m)) return "";
+    const y = day.getFullYear();
+    const mo = (day.getMonth() + 1).toString().padStart(2, "0");
+    const d = day.getDate().toString().padStart(2, "0");
+    const hh = h.toString().padStart(2, "0");
+    const mm = m.toString().padStart(2, "0");
+    return `${y}-${mo}-${d}T${hh}:${mm}:00.000Z`;
+  }, [selectedDay, startTimeOfDay]);
+
+  // Keep form.start in sync with computedStart
+  useEffect(() => {
+    form.setFieldValue("start", computedStart);
+  }, [computedStart, form.setFieldValue]);
+
+  const canCalculateEnd =
+    !!form.values.pickupAddress?.trim() &&
+    !!form.values.destinationAddress?.trim() &&
+    !!computedStart;
+
+  const estimatedEndQuery = api.bookings.getEstimatedEndTime.useQuery(
+    {
+      pickupAddress: form.values.pickupAddress,
+      destinationAddress: form.values.destinationAddress,
+      startTime: computedStart,
+    },
+    { enabled: canCalculateEnd, staleTime: 5 * 60 * 1000 },
+  );
+
+  useEffect(() => {
+    if (estimatedEndQuery.data) {
+      form.setFieldValue("end", estimatedEndQuery.data.estimatedEndTime);
+    }
+  }, [estimatedEndQuery.data, form.setFieldValue]);
+
+  const canCheckAvailability =
+    !!form.values.driverId?.trim() &&
+    !!form.values.start &&
+    !!form.values.end &&
+    isEndAfterStart(form.values.start, form.values.end);
+
+  const availabilityQuery = api.bookings.isDriverAvailable.useQuery(
+    {
+      driverId: form.values.driverId,
+      startTime: form.values.start,
+      endTime: form.values.end,
+      pickupAddress: form.values.pickupAddress?.trim() || undefined,
+      destinationAddress: form.values.destinationAddress?.trim() || undefined,
+    },
+    { enabled: canCheckAvailability },
+  );
+
   const createMutation = api.bookings.create.useMutation({
     onSuccess: async () => {
       notifications.show({ color: "green", message: "Booking created!" });
@@ -52,6 +267,17 @@ export default function BookingDebugPage() {
       await allBookingsQuery.refetch();
 
       form.reset();
+      const exampleStartDate = new Date(EXAMPLE_BOOKING.start);
+      setSelectedDay(
+        new Date(
+          exampleStartDate.getUTCFullYear(),
+          exampleStartDate.getUTCMonth(),
+          exampleStartDate.getUTCDate(),
+        ),
+      );
+      const h = exampleStartDate.getUTCHours().toString().padStart(2, "0");
+      const m = exampleStartDate.getUTCMinutes().toString().padStart(2, "0");
+      setStartTimeOfDay(`${h}:${m}`);
     },
     onError: (err) => {
       notifications.show({ color: "red", message: err.message });
@@ -89,49 +315,28 @@ export default function BookingDebugPage() {
     label: s.replace("-", " ").replace(/\b\w/g, (c) => c.toUpperCase()),
   }));
 
+  const endAfterStart = useMemo(() => {
+    if (!form.values.start || !form.values.end) return true;
+    return isEndAfterStart(form.values.start, form.values.end);
+  }, [form.values.start, form.values.end]);
+
   return (
     <div className={styles.container}>
       <h1>Booking API Debug Panel</h1>
 
-      <Group>
-        <TextInput
-          label="Booking ID"
-          type="number"
-          value={bookingId}
-          onChange={(e) => setBookingId(Number(e.target.value))}
-        />
-        <Button loading={bookingQuery.isFetching} onClick={() => bookingQuery.refetch()}>
-          Fetch Booking
-        </Button>
-      </Group>
-
-      <Divider my="md" />
-
-      {/* UPDATE STATUS */}
-      <Select
-        label="Update Status"
-        value={form.values.status}
-        onChange={(v) => form.setFieldValue("status", v as BookingStatusValue)}
-        data={statusOptions}
-      />
-
-      <Button
-        mt="sm"
-        onClick={() => updateMutation.mutate({ id: bookingId, status: form.values.status })}
-      >
-        Update Status
-      </Button>
-
-      <Button color="red" mt="sm" onClick={() => cancelMutation.mutate({ id: bookingId })}>
-        Cancel Booking
-      </Button>
-
-      <Divider my="xl" />
-
       {/* CREATE FORM */}
       <h2>Create Booking</h2>
       <form
-        onSubmit={form.onSubmit((values) =>
+        onSubmit={form.onSubmit((values) => {
+          // Front-end guard matching backend refine()
+          if (!isEndAfterStart(values.start, values.end)) {
+            notifications.show({
+              color: "red",
+              message: "End time must be after start time.",
+            });
+            return;
+          }
+
           createMutation.mutate({
             title: values.title,
             pickupAddress: values.pickupAddress,
@@ -141,10 +346,11 @@ export default function BookingDebugPage() {
             startTime: values.start,
             endTime: values.end,
             purpose: values.purpose || undefined,
+            phoneNumber: values.phoneNumber?.trim() || null,
             driverId: values.driverId || null,
             status: values.status,
-          }),
-        )}
+          });
+        })}
         className={styles.formGrid}
       >
         <TextInput withAsterisk label="Title" {...form.getInputProps("title")} />
@@ -154,23 +360,148 @@ export default function BookingDebugPage() {
           label="Destination Address"
           {...form.getInputProps("destinationAddress")}
         />
-        <Textarea withAsterisk label="Passenger Info" {...form.getInputProps("passengerInfo")} />
+        <TextInput withAsterisk label="Passenger Info" {...form.getInputProps("passengerInfo")} />
+        <TextInput
+          label="Phone number (optional)"
+          placeholder="+1 (403) 760-9834"
+          maxLength={25}
+          {...form.getInputProps("phoneNumber")}
+        />
         <TextInput withAsterisk label="Agency ID" {...form.getInputProps("agencyId")} />
         <TextInput label="Purpose (optional)" {...form.getInputProps("purpose")} />
-        <TextInput label="Driver ID (optional)" {...form.getInputProps("driverId")} />
-        <TextInput
-          withAsterisk
-          label="Starts"
-          placeholder="2025-01-01T10:00:00Z"
-          {...form.getInputProps("start")}
+
+        <DateInput
+          label="Day"
+          placeholder="Pick a day"
+          value={selectedDay}
+          onChange={(v) => {
+            if (v == null) {
+              setSelectedDay(null);
+              return;
+            }
+            const value = v as unknown;
+            if (value instanceof Date) {
+              setSelectedDay(new Date(value.getFullYear(), value.getMonth(), value.getDate()));
+            } else {
+              const str = (typeof value === "string" ? value : "").trim();
+              if (!str) return;
+              const parts = str.split("-").map(Number);
+              const [y, m, day] = parts;
+              if (y != null && m != null && day != null) {
+                setSelectedDay(new Date(y, m - 1, day));
+              }
+            }
+          }}
+          valueFormat="MMM D, YYYY"
+          clearable
         />
+
+        <Select
+          label="Driver (optional)"
+          placeholder="Select driver"
+          data={driverOptions}
+          searchable
+          clearable
+          {...form.getInputProps("driverId")}
+        />
+
+        {canShowDriverAvailability && (
+          <div className={styles.bookedSlotsTable}>
+            <h4>
+              Driver bookings for{" "}
+              {selectedDay?.toLocaleDateString("en-US", {
+                weekday: "short",
+                month: "short",
+                day: "numeric",
+                year: "numeric",
+              })}
+            </h4>
+            {allBookingsQuery.isLoading ? (
+              <Text size="sm" c="dimmed">
+                Loading…
+              </Text>
+            ) : (
+              <DriverScheduleTable
+                bookings={allBookingsQuery.data ?? []}
+                day={selectedDay}
+                driverId={form.values.driverId ?? ""}
+              />
+            )}
+          </div>
+        )}
+
+        <TimeInput
+          label="Start time"
+          placeholder="Select time"
+          value={startTimeOfDay}
+          onChange={(v) => setStartTimeOfDay(v.target.value)}
+        />
+
+        {canCalculateEnd && estimatedEndQuery.data && (
+          <div className={styles.debugOutput}>
+            <h4>End time calculation</h4>
+            <pre>
+              {estimatedEndQuery.data.usedFallback &&
+                "Using fallback travel time (API unavailable).\n"}
+              {estimatedEndQuery.data.usedCached && "(From cache)\n"}
+              Calculated driving time: {estimatedEndQuery.data.drivingTimeMinutes} min
+              {"\n"}
+              Total booking time: {estimatedEndQuery.data.totalBookingMinutes} min (15 min pickup
+              wait + {estimatedEndQuery.data.drivingTimeMinutes} min travel)
+              {"\n"}
+              Start time: {estimatedEndQuery.data.startTime}
+              {"\n"}
+              Estimated end time: {estimatedEndQuery.data.estimatedEndTime}
+            </pre>
+          </div>
+        )}
+
         <TextInput
-          withAsterisk
           label="Ends"
-          placeholder="2025-01-01T12:00:00Z"
-          {...form.getInputProps("end")}
+          value={
+            estimatedEndQuery.data?.estimatedEndTime
+              ? new Date(estimatedEndQuery.data.estimatedEndTime).toLocaleTimeString("en-US", {
+                  hour: "numeric",
+                  minute: "2-digit",
+                  hour12: true,
+                  timeZone: "UTC",
+                })
+              : ""
+          }
+          placeholder={
+            estimatedEndQuery.isLoading
+              ? "Calculating…"
+              : "Enter pickup, destination, and start time to calculate"
+          }
+          readOnly
+          styles={{ input: { cursor: "default" } }}
         />
 
+        {!endAfterStart && (
+          <p className={styles.errorMessage}>End time must be after start time.</p>
+        )}
+
+        {canCheckAvailability && availabilityQuery.isLoading && (
+          <Text size="sm" c="dimmed">
+            Checking availability…
+          </Text>
+        )}
+        {canCheckAvailability && availabilityQuery.data && (
+          <Alert
+            color={availabilityQuery.data.available ? "green" : "red"}
+            title={availabilityQuery.data.available ? "Driver available" : "Driver not available"}
+          >
+            {availabilityQuery.data.available
+              ? "Driver is available for this time."
+              : (availabilityQuery.data.reason ?? "Driver has another booking at this time.")}
+          </Alert>
+        )}
+        {!canCheckAvailability && form.values.driverId?.trim() && (
+          <Text size="sm" c="dimmed">
+            Enter start and end time to check driver availability.
+          </Text>
+        )}
+
         <Button type="submit" className={styles.submitButton}>
           Create
         </Button>
@@ -184,14 +515,45 @@ export default function BookingDebugPage() {
         <pre className={styles.jsonBlock}>{JSON.stringify(createMutation.data, null, 2)}</pre>
       )}
 
-      {/* DATA VIEWS */}
+      <Divider my="xl" />
+
+      {/* SINGLE BOOKING */}
       <section>
         <h3>Single Booking</h3>
+        <Group>
+          <TextInput
+            label="Booking ID"
+            type="number"
+            value={bookingId}
+            onChange={(e) => setBookingId(Number(e.target.value))}
+          />
+          <Button loading={bookingQuery.isFetching} onClick={() => bookingQuery.refetch()}>
+            Fetch Booking
+          </Button>
+        </Group>
+        <Select
+          label="Update Status"
+          value={form.values.status}
+          onChange={(v) => form.setFieldValue("status", v as BookingStatusValue)}
+          data={statusOptions}
+          mt="sm"
+        />
+        <Group mt="sm">
+          <Button
+            onClick={() => updateMutation.mutate({ id: bookingId, status: form.values.status })}
+          >
+            Update Status
+          </Button>
+          <Button color="red" onClick={() => cancelMutation.mutate({ id: bookingId })}>
+            Cancel Booking
+          </Button>
+        </Group>
         <pre className={styles.jsonBlock}>
           {bookingQuery.data ? JSON.stringify(bookingQuery.data, null, 2) : "No data"}
         </pre>
       </section>
 
+      {/* ALL BOOKINGS */}
       <section>
         <h3>All Bookings</h3>
         <Button loading={allBookingsQuery.isFetching} onClick={() => allBookingsQuery.refetch()}>
diff --git a/src/constants/driver-assignment.ts b/src/constants/driver-assignment.ts
new file mode 100644
index 0000000..032c3db
--- /dev/null
+++ b/src/constants/driver-assignment.ts
@@ -0,0 +1,19 @@
+/**
+ * Constants for driver trip assignment system
+ * These values control how driver availability and earliest booking times are calculated
+ */
+
+/** Wait time at pickup location (in minutes) */
+export const PICKUP_WAIT_TIME_MINUTES = 15;
+
+/** Buffer time added after travel calculations (in minutes) */
+export const TRAVEL_BUFFER_MINUTES = 15;
+
+/** Time slot rounding increment (in minutes) */
+export const TIME_SLOT_ROUNDING_MINUTES = 15;
+
+/**
+ * Only run "travel from previous destination to new pickup" check when the new
+ * booking start is within this many minutes after the previous booking end.
+ */
+export const MAX_GAP_MINUTES_FOR_TRAVEL_CHECK = 60;
diff --git a/src/lib/datetime.ts b/src/lib/datetime.ts
new file mode 100644
index 0000000..9e663dc
--- /dev/null
+++ b/src/lib/datetime.ts
@@ -0,0 +1,37 @@
+import { TIME_SLOT_ROUNDING_MINUTES } from "@/constants/driver-assignment";
+
+/**
+ * Rounds a date up to the nearest time slot increment (default: 15 minutes)
+ * Examples:
+ * - 14:07 → 14:15
+ * - 14:15 → 14:15
+ * - 14:16 → 14:30
+ * - 14:45 → 14:45
+ * - 14:46 → 15:00
+ *
+ * @param date - The date to round up
+ * @param incrementMinutes - The increment in minutes (default: 15)
+ * @returns A new Date rounded up to the nearest increment
+ */
+export function roundUpToNearestIncrement(
+  date: Date,
+  incrementMinutes: number = TIME_SLOT_ROUNDING_MINUTES,
+): Date {
+  const rounded = new Date(date);
+  const minutes = rounded.getMinutes();
+  const roundedMinutes = Math.ceil(minutes / incrementMinutes) * incrementMinutes;
+
+  // If rounding goes past 60 minutes, add an hour and reset minutes
+  if (roundedMinutes >= 60) {
+    rounded.setHours(rounded.getHours() + 1);
+    rounded.setMinutes(roundedMinutes - 60);
+  } else {
+    rounded.setMinutes(roundedMinutes);
+  }
+
+  // Reset seconds and milliseconds
+  rounded.setSeconds(0);
+  rounded.setMilliseconds(0);
+
+  return rounded;
+}
diff --git a/src/lib/google-maps.ts b/src/lib/google-maps.ts
new file mode 100644
index 0000000..61ffde9
--- /dev/null
+++ b/src/lib/google-maps.ts
@@ -0,0 +1,106 @@
+import { env } from "@/env";
+
+/**
+ * Response from Google Maps Distance Matrix API
+ */
+interface DistanceMatrixResponse {
+  status: string;
+  rows: Array<{
+    elements: Array<{
+      status: string;
+      duration?: {
+        value: number; // Duration in seconds
+        text: string; // Human-readable duration
+      };
+      distance?: {
+        value: number; // Distance in meters
+        text: string; // Human-readable distance
+      };
+    }>;
+  }>;
+  error_message?: string;
+}
+
+/**
+ * Options for calculating travel time
+ */
+export interface TravelTimeOptions {
+  /** Travel mode (default: "driving") */
+  mode?: "driving" | "walking" | "bicycling" | "transit";
+  /** Unit system (default: "metric") */
+  units?: "metric" | "imperial";
+}
+
+/**
+ * Calculates travel time between two addresses using Google Maps Distance Matrix API
+ *
+ * @param originAddress - Origin address as a string
+ * @param destinationAddress - Destination address as a string
+ * @param options - Optional travel mode and unit settings
+ * @returns Travel duration in minutes, or null if calculation fails
+ * @throws Error if GOOGLE_MAPS_API_KEY is not configured
+ */
+export async function getTravelTimeMinutes(
+  originAddress: string,
+  destinationAddress: string,
+  options: TravelTimeOptions = {},
+): Promise<number | null> {
+  const apiKey = env.GOOGLE_MAPS_API_KEY;
+
+  if (!apiKey) {
+    throw new Error("GOOGLE_MAPS_API_KEY is not configured");
+  }
+
+  const { mode = "driving", units = "metric" } = options;
+
+  // Build the Distance Matrix API URL
+  const baseUrl = "https://maps.googleapis.com/maps/api/distancematrix/json";
+  const params = new URLSearchParams({
+    origins: originAddress,
+    destinations: destinationAddress,
+    mode,
+    units,
+    key: apiKey,
+  });
+
+  const url = `${baseUrl}?${params.toString()}`;
+
+  try {
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new Error(`Google Maps API request failed: ${response.status} ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as DistanceMatrixResponse;
+
+    // Check for API-level errors
+    if (data.status !== "OK") {
+      const errorMsg = data.error_message || `API returned status: ${data.status}`;
+      console.error("Google Maps Distance Matrix API error:", errorMsg);
+      return null;
+    }
+
+    // Check if we have valid data
+    if (!data.rows?.[0]?.elements?.[0] || data.rows[0].elements[0].status !== "OK") {
+      const elementStatus = data.rows[0]?.elements?.[0]?.status || "UNKNOWN";
+      console.error("Google Maps Distance Matrix element error:", elementStatus);
+      return null;
+    }
+
+    const duration = data.rows[0].elements[0].duration;
+
+    if (!duration) {
+      console.error("Google Maps Distance Matrix: No duration data returned");
+      return null;
+    }
+
+    // Convert seconds to minutes and round up
+    const minutes = Math.ceil(duration.value / 60);
+    return minutes;
+  } catch (error) {
+    // Log error but return null instead of throwing to allow graceful degradation
+    console.error("Error calculating travel time:", error);
+    return null;
+  }
+}
diff --git a/src/server/api/routers/bookings.ts b/src/server/api/routers/bookings.ts
index feb1376..63f68f8 100644
--- a/src/server/api/routers/bookings.ts
+++ b/src/server/api/routers/bookings.ts
@@ -2,19 +2,360 @@ import { TRPCError } from "@trpc/server";
 import dayjs from "dayjs";
 import timezone from "dayjs/plugin/timezone";
 import utc from "dayjs/plugin/utc";
-import { and, desc, eq, gte, lt, or } from "drizzle-orm";
+import { and, asc, desc, eq, gt, gte, lt, lte, ne, or } from "drizzle-orm";
 import { z } from "zod";
+import {
+  MAX_GAP_MINUTES_FOR_TRAVEL_CHECK,
+  PICKUP_WAIT_TIME_MINUTES,
+  TRAVEL_BUFFER_MINUTES,
+} from "@/constants/driver-assignment";
+import { roundUpToNearestIncrement } from "@/lib/datetime";
+import { getTravelTimeMinutes } from "@/lib/google-maps";
+import type { db } from "@/server/db";
 import { isoTimeRegex, isoTimeRegexFourDigitYears } from "@/types/validation";
+import { user } from "../../db/auth-schema";
 import { BOOKING_STATUS, type BookingInsertType, bookings } from "../../db/booking-schema";
 import { createTRPCRouter, protectedProcedure } from "../trpc";
 
 dayjs.extend(utc); //Allows dayjs to work in UTC
 dayjs.extend(timezone); //Allows dayjs to convert dates between time zones
 
+/** Fallback travel minutes per leg when Google Maps API fails */
+const FALLBACK_TRAVEL_MINUTES = 15;
+
+/** TTL for in-memory travel time cache (10 minutes) */
+const TRAVEL_TIME_CACHE_TTL_MS = 10 * 60 * 1000;
+
+const travelTimeCache = new Map<string, { value: number; expiresAt: number }>();
+
 const StatusZ = z.enum(BOOKING_STATUS); // ← uses "cancelled" (double-L)
 
+type DbContext = { db: typeof db };
+
+/**
+ * Throws if the session user is not admin and not the booking's agency.
+ * @param session - Session with user id and role
+ * @param agencyId - Booking's agency id
+ * @throws TRPCError FORBIDDEN when not allowed
+ */
+function assertCanAccessBooking(
+  session: { user: { id: string; role?: string | null } },
+  agencyId: string,
+): void {
+  const role = session.user.role ?? "user";
+  const allowed = role === "admin" || agencyId === session.user.id;
+  if (!allowed) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "You don't have permission to access this booking.",
+    });
+  }
+}
+
+/** Overlap: existing.startTime < endTime AND existing.endTime > startTime */
+async function findOverlappingBooking(
+  ctx: DbContext,
+  params: {
+    driverId: string;
+    startTime: string;
+    endTime: string;
+    excludeBookingId?: number;
+  },
+): Promise<{ id: number } | undefined> {
+  const { driverId, startTime, endTime, excludeBookingId } = params;
+  const baseCondition = and(
+    eq(bookings.driverId, driverId),
+    ne(bookings.status, "cancelled"),
+    lt(bookings.startTime, endTime),
+    gt(bookings.endTime, startTime),
+  );
+  const whereCondition =
+    excludeBookingId !== undefined
+      ? and(baseCondition, ne(bookings.id, excludeBookingId))
+      : baseCondition;
+
+  const [row] = await ctx.db
+    .select({ id: bookings.id })
+    .from(bookings)
+    .where(whereCondition)
+    .limit(1);
+  return row;
+}
+
+/**
+ * Shared helper: validate that the driver has enough time to travel between
+ * adjacent bookings. Uses lte/gte to include back-to-back (touching) times.
+ * Returns { valid, reason } — does not throw.
+ */
+async function validateTravelBetweenAdjacentBookings(
+  ctx: DbContext,
+  params: {
+    driverId: string;
+    startTime: string;
+    endTime: string;
+    pickupAddress: string;
+    destinationAddress: string;
+    excludeBookingId?: number;
+  },
+): Promise<{ valid: boolean; reason?: string }> {
+  const { driverId, startTime, endTime, pickupAddress, destinationAddress, excludeBookingId } =
+    params;
+
+  const baseDriverCondition = and(
+    eq(bookings.driverId, driverId),
+    ne(bookings.status, "cancelled"),
+  );
+  const excludeCond =
+    excludeBookingId !== undefined ? ne(bookings.id, excludeBookingId) : undefined;
+
+  // Previous booking: endTime <= newStartTime (include back-to-back)
+  const [prevBooking] = await ctx.db
+    .select({
+      endTime: bookings.endTime,
+      destinationAddress: bookings.destinationAddress,
+    })
+    .from(bookings)
+    .where(
+      and(
+        baseDriverCondition,
+        lte(bookings.endTime, startTime),
+        ...(excludeCond ? [excludeCond] : []),
+      ),
+    )
+    .orderBy(desc(bookings.endTime))
+    .limit(1);
+
+  if (
+    prevBooking?.endTime &&
+    prevBooking?.destinationAddress &&
+    prevBooking.destinationAddress.trim() !== ""
+  ) {
+    const prevEndMs = new Date(prevBooking.endTime).getTime();
+    const newStartMs = new Date(startTime).getTime();
+    const gapMinutes = (newStartMs - prevEndMs) / (60 * 1000);
+
+    if (gapMinutes <= MAX_GAP_MINUTES_FOR_TRAVEL_CHECK) {
+      const travelMinutesResult = await getTravelTimeMinutes(
+        prevBooking.destinationAddress,
+        pickupAddress,
+      );
+      const travelMinutes = travelMinutesResult ?? FALLBACK_TRAVEL_MINUTES;
+      if (travelMinutesResult === null) {
+        console.warn(
+          "Travel time lookup failed, using fallback:",
+          { from: prevBooking.destinationAddress, to: pickupAddress },
+          `Using ${FALLBACK_TRAVEL_MINUTES} min fallback`,
+        );
+      }
+      const requiredMinutes = travelMinutes + TRAVEL_BUFFER_MINUTES;
+
+      if (gapMinutes < requiredMinutes) {
+        return {
+          valid: false,
+          reason: `Driver needs ${travelMinutes} min to travel from previous booking's destination to this pickup (plus ${TRAVEL_BUFFER_MINUTES} min buffer). Not enough time between bookings.`,
+        };
+      }
+    }
+  }
+
+  // Next booking: startTime >= newEndTime (include back-to-back)
+  const [nextBooking] = await ctx.db
+    .select({
+      startTime: bookings.startTime,
+      pickupAddress: bookings.pickupAddress,
+    })
+    .from(bookings)
+    .where(
+      and(
+        baseDriverCondition,
+        gte(bookings.startTime, endTime),
+        ...(excludeCond ? [excludeCond] : []),
+      ),
+    )
+    .orderBy(asc(bookings.startTime))
+    .limit(1);
+
+  if (
+    nextBooking?.startTime &&
+    nextBooking?.pickupAddress &&
+    nextBooking.pickupAddress.trim() !== ""
+  ) {
+    const newEndMs = new Date(endTime).getTime();
+    const nextStartMs = new Date(nextBooking.startTime).getTime();
+    const gapMinutes = (nextStartMs - newEndMs) / (60 * 1000);
+
+    if (gapMinutes <= MAX_GAP_MINUTES_FOR_TRAVEL_CHECK) {
+      const travelMinutesResult = await getTravelTimeMinutes(
+        destinationAddress,
+        nextBooking.pickupAddress,
+      );
+      const travelMinutes = travelMinutesResult ?? FALLBACK_TRAVEL_MINUTES;
+      if (travelMinutesResult === null) {
+        console.warn(
+          "Travel time lookup failed, using fallback:",
+          { from: destinationAddress, to: nextBooking.pickupAddress },
+          `Using ${FALLBACK_TRAVEL_MINUTES} min fallback`,
+        );
+      }
+      const requiredMinutes = travelMinutes + TRAVEL_BUFFER_MINUTES;
+
+      if (gapMinutes < requiredMinutes) {
+        return {
+          valid: false,
+          reason: `Driver needs ${travelMinutes} min to travel from this destination to the next booking's pickup (plus ${TRAVEL_BUFFER_MINUTES} min buffer). Not enough time between bookings.`,
+        };
+      }
+    }
+  }
+
+  return { valid: true };
+}
+
+/** Overlap + travel validation; throws TRPCError on failure. */
+async function validateDriverForSlot(
+  ctx: DbContext,
+  params: {
+    driverId: string;
+    startTime: string;
+    endTime: string;
+    pickupAddress: string;
+    destinationAddress: string;
+    excludeBookingId?: number;
+  },
+): Promise<void> {
+  if (await findOverlappingBooking(ctx, params)) {
+    throw new TRPCError({
+      code: "CONFLICT",
+      message: "Driver has another booking at that time.",
+    });
+  }
+  const travelResult = await validateTravelBetweenAdjacentBookings(ctx, params);
+  if (!travelResult.valid) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: travelResult.reason ?? "Not enough travel time between bookings.",
+    });
+  }
+}
+
 export const bookingsRouter = createTRPCRouter({
-  // POST /bookings (create)
+  /** Returns the current user id and role for the debug form default agencyId. */
+  getCurrentUser: protectedProcedure.query(async ({ ctx }) => {
+    return {
+      id: ctx.session.user.id,
+      role: ctx.session.user.role ?? "user",
+    };
+  }),
+
+  /** Returns all drivers (id, name; email only for admins). */
+  listDrivers: protectedProcedure.query(async ({ ctx }) => {
+    const isAdmin = ctx.session.user.role === "admin";
+    const drivers = await ctx.db
+      .select({
+        id: user.id,
+        name: user.name,
+        ...(isAdmin ? { email: user.email } : {}),
+      })
+      .from(user)
+      .where(eq(user.role, "driver"))
+      .orderBy(asc(user.name));
+
+    return drivers;
+  }),
+
+  /** Checks driver availability for a time range (overlap and travel time). */
+  isDriverAvailable: protectedProcedure
+    .input(
+      z.object({
+        driverId: z.string().min(1),
+        startTime: z.string().datetime(),
+        endTime: z.string().datetime(),
+        pickupAddress: z.string().min(1).optional(),
+        destinationAddress: z.string().min(1).optional(),
+        /**
+         * Optional booking ID to exclude from the overlap check.
+         * Useful when editing an existing booking.
+         */
+        excludeBookingId: z.number().optional(),
+      }),
+    )
+    .query(async ({ ctx, input }) => {
+      const { driverId, startTime, endTime, excludeBookingId, pickupAddress, destinationAddress } =
+        input;
+
+      if (await findOverlappingBooking(ctx, { driverId, startTime, endTime, excludeBookingId })) {
+        return { available: false, reason: "Driver has another booking at that time." };
+      }
+
+      if (pickupAddress && destinationAddress) {
+        const travelResult = await validateTravelBetweenAdjacentBookings(ctx, {
+          driverId,
+          startTime,
+          endTime,
+          pickupAddress,
+          destinationAddress,
+          excludeBookingId,
+        });
+        if (!travelResult.valid) {
+          return { available: false, reason: travelResult.reason };
+        }
+      }
+
+      return { available: true };
+    }),
+
+  /** Returns estimated end time from start + pickup wait + travel time (cached). */
+  getEstimatedEndTime: protectedProcedure
+    .input(
+      z.object({
+        pickupAddress: z.string().min(1),
+        destinationAddress: z.string().min(1),
+        startTime: z.string().datetime(),
+      }),
+    )
+    .query(async ({ input }) => {
+      const cacheKey = `${input.pickupAddress}|${input.destinationAddress}`;
+      const now = Date.now();
+      const cached = travelTimeCache.get(cacheKey);
+      let drivingTimeMinutes: number;
+      let usedCached: boolean;
+      let usedFallback: boolean;
+      if (cached && cached.expiresAt > now) {
+        drivingTimeMinutes = cached.value;
+        usedCached = true;
+        usedFallback = false;
+      } else {
+        const apiResult = await getTravelTimeMinutes(input.pickupAddress, input.destinationAddress);
+        usedCached = false;
+        usedFallback = apiResult === null;
+        drivingTimeMinutes = apiResult ?? FALLBACK_TRAVEL_MINUTES;
+        travelTimeCache.set(cacheKey, {
+          value: drivingTimeMinutes,
+          expiresAt: now + TRAVEL_TIME_CACHE_TTL_MS,
+        });
+      }
+
+      const totalBookingMinutes = PICKUP_WAIT_TIME_MINUTES + drivingTimeMinutes;
+
+      const start = new Date(input.startTime);
+      const end = new Date(start.getTime());
+      end.setMinutes(end.getMinutes() + totalBookingMinutes);
+
+      const estimatedEndTime = roundUpToNearestIncrement(end).toISOString();
+
+      return {
+        location1: input.pickupAddress,
+        location2: input.destinationAddress,
+        drivingTimeMinutes,
+        totalBookingMinutes,
+        startTime: input.startTime,
+        estimatedEndTime,
+        usedCached,
+        usedFallback,
+      };
+    }),
+
+  /** Creates a booking; validates driver slot when driverId is set. */
   create: protectedProcedure
     .input(
       z
@@ -31,6 +372,7 @@ export const bookingsRouter = createTRPCRouter({
 
           // Optional fields
           purpose: z.string().optional(),
+          phoneNumber: z.string().max(25).optional().nullable(),
           driverId: z.string().nullable().optional(),
           status: StatusZ.optional(),
         })
@@ -60,10 +402,26 @@ export const bookingsRouter = createTRPCRouter({
 
       // Only include optional fields if they are actually provided
       if (input.purpose !== undefined) bookingData.purpose = input.purpose;
+      if (input.phoneNumber !== undefined) bookingData.phoneNumber = input.phoneNumber;
       if (input.driverId !== undefined) bookingData.driverId = input.driverId;
       if (input.status !== undefined) bookingData.status = input.status;
 
-      const [row] = await ctx.db.insert(bookings).values(bookingData).returning();
+      const rows = await ctx.db.transaction(async (tx) => {
+        if (input.driverId) {
+          await validateDriverForSlot(
+            { db: tx as unknown as typeof db },
+            {
+              driverId: input.driverId,
+              startTime: input.startTime,
+              endTime: input.endTime,
+              pickupAddress: input.pickupAddress,
+              destinationAddress: input.destinationAddress,
+            },
+          );
+        }
+        return tx.insert(bookings).values(bookingData).returning();
+      });
+      const row = rows[0];
 
       if (!row) {
         throw new TRPCError({
@@ -74,6 +432,7 @@ export const bookingsRouter = createTRPCRouter({
       return row;
     }),
 
+  /** Returns a single booking by id after access check. */
   getById: protectedProcedure.input(z.object({ id: z.number() })).query(async ({ ctx, input }) => {
     const row = await ctx.db
       .select()
@@ -88,21 +447,11 @@ export const bookingsRouter = createTRPCRouter({
         message: "Booking not found",
       });
 
-    const userId = ctx.session.user.id;
-    const role = ctx.session.user.role ?? "user"; // default safety
-
-    const allowed = role === "admin" || row.agencyId === userId;
-
-    if (!allowed) {
-      throw new TRPCError({
-        code: "FORBIDDEN",
-        message: "You don’t have permission to view this booking.",
-      });
-    }
-
+    assertCanAccessBooking(ctx.session, row.agencyId);
     return row;
   }),
 
+  /** Returns bookings (filtered by date and optional survey flag); access by agency. */
   getAll: protectedProcedure
     .input(
       z
@@ -120,8 +469,12 @@ export const bookingsRouter = createTRPCRouter({
       let endDate = input?.endDate ?? "";
 
       if (input === undefined || input.endDate === undefined) {
-        //No end date given, assign one to input.endDate
-        endDate = dayjs().utc().add(50, "year").tz("America/Hermosillo").format();
+        // No end date given; use explicit format so result matches isoTimeRegexFourDigitYears (-07:00)
+        endDate = dayjs()
+          .utc()
+          .add(50, "year")
+          .tz("America/Hermosillo")
+          .format("YYYY-MM-DDTHH:mm:ssZ");
       }
 
       let startAndEndDateErrorMessage = "Invalid: ";
@@ -171,7 +524,7 @@ export const bookingsRouter = createTRPCRouter({
         .orderBy(desc(bookings.createdAt));
     }),
 
-  // PATCH /bookings/:id
+  /** Updates a booking; re-validates driver when driver or time/address changes. */
   update: protectedProcedure
     .input(
       z.object({
@@ -183,6 +536,8 @@ export const bookingsRouter = createTRPCRouter({
         passengerInfo: z.string().optional(),
         driverId: z.string().optional().nullable(),
         status: StatusZ.optional(),
+        startTime: z.string().datetime().optional(),
+        endTime: z.string().datetime().optional(),
       }),
     )
     .mutation(async ({ ctx, input }) => {
@@ -203,38 +558,59 @@ export const bookingsRouter = createTRPCRouter({
         });
       }
 
-      // 2) Authorization check
-      const userId = ctx.session.user.id;
-      const role = ctx.session.user.role ?? "user";
-
-      const allowed = role === "admin" || existing.agencyId === userId;
-
-      if (!allowed) {
-        throw new TRPCError({
-          code: "FORBIDDEN",
-          message: "You cannot update this booking.",
-        });
-      }
+      assertCanAccessBooking(ctx.session, existing.agencyId);
 
+      const userId = ctx.session.user.id;
       // 3) Filter only defined updates
       const updatesToApply = Object.fromEntries(
         Object.entries(updates).filter(([, v]) => v !== undefined),
       );
 
-      // 4) Perform update with updatedBy field set
-      const res = await ctx.db
-        .update(bookings)
-        .set({
-          ...updatesToApply,
-          updatedBy: userId,
-        })
-        .where(eq(bookings.id, id))
-        .returning();
+      const driverId =
+        updatesToApply.driverId !== undefined ? updatesToApply.driverId : existing.driverId;
+      const needsDriverValidation =
+        driverId != null &&
+        driverId !== "" &&
+        (updatesToApply.driverId !== undefined ||
+          updatesToApply.startTime !== undefined ||
+          updatesToApply.endTime !== undefined ||
+          updatesToApply.pickupAddress !== undefined ||
+          updatesToApply.destinationAddress !== undefined);
+
+      const res = await ctx.db.transaction(async (tx) => {
+        if (needsDriverValidation) {
+          const proposedStart = updatesToApply.startTime ?? existing.startTime;
+          const proposedEnd = updatesToApply.endTime ?? existing.endTime;
+          const proposedPickup = updatesToApply.pickupAddress ?? existing.pickupAddress;
+          const proposedDest = updatesToApply.destinationAddress ?? existing.destinationAddress;
+
+          await validateDriverForSlot(
+            { db: tx as unknown as typeof db },
+            {
+              driverId,
+              startTime: proposedStart,
+              endTime: proposedEnd,
+              pickupAddress: proposedPickup,
+              destinationAddress: proposedDest,
+              excludeBookingId: id,
+            },
+          );
+        }
+
+        return tx
+          .update(bookings)
+          .set({
+            ...updatesToApply,
+            updatedBy: userId,
+          })
+          .where(eq(bookings.id, id))
+          .returning();
+      });
 
       return res[0];
     }),
 
-  // PATCH /bookings/:id/cancel
+  /** Sets booking status to cancelled. */
   cancel: protectedProcedure
     .input(z.object({ id: z.number() }))
     .mutation(async ({ ctx, input }) => {
@@ -252,17 +628,7 @@ export const bookingsRouter = createTRPCRouter({
         });
       }
 
-      const userId = ctx.session.user.id;
-      const role = ctx.session.user.role ?? "user";
-
-      const allowed = role === "admin" || existing.agencyId === userId;
-
-      if (!allowed) {
-        throw new TRPCError({
-          code: "FORBIDDEN",
-          message: "You cannot cancel this booking.",
-        });
-      }
+      assertCanAccessBooking(ctx.session, existing.agencyId);
 
       return ctx.db
         .update(bookings)
diff --git a/src/server/db/booking-schema.ts b/src/server/db/booking-schema.ts
index 9f7c5e5..ff320dd 100644
--- a/src/server/db/booking-schema.ts
+++ b/src/server/db/booking-schema.ts
@@ -39,8 +39,17 @@ export const bookings = pgTable(
     createdBy: text("created_by").references(() => user.id),
     updatedBy: text("updated_by").references(() => user.id),
   },
-  //Runs after the table is created
-  (table) => [index("bookings_start_time_idx").on(table.startTime)],
+  // Runs after the table is created
+  (table) => [
+    index("bookings_start_time_idx").on(table.startTime),
+    index("bookings_driver_overlap_idx").on(
+      table.driverId,
+      table.status,
+      table.startTime,
+      table.endTime,
+    ),
+    index("bookings_driver_end_time_idx").on(table.driverId, table.endTime),
+  ],
 );
 
 export const bookingsRelations = relations(bookings, ({ one }) => ({