diff --git a/src/components/ApplicationForm.tsx b/src/components/ApplicationForm.tsx
index 046c94b..1d9e0ec 100644
--- a/src/components/ApplicationForm.tsx
+++ b/src/components/ApplicationForm.tsx
@@ -9,23 +9,24 @@ import {
     updateApplicantPersonalInfo,
 } from "@/lib/supabase/actions/applicants.actions";
 
-import type { ApplicantType } from "@/types";
+import type {
+    ApplicantType,
+} from "@/types";
 
 const branches = [
     "Aerospace Engineering",
-    "Chemical Engineering",
+    "Bachelor of Design (B.Des)",
     "Civil Engineering",
     "Computer Science & Engineering",
-    "Electrical Engineering",
-    "Electronics & Communication Engineering",
-    "Mechanical Engineering",
-    "Production & Industrial Engineering",
     "Computer Science & Engineering (AI)",
     "Computer Science & Engineering (DS)",
+    "Electrical Engineering",
+    "Electronics & Communication Engineering",
     "Electronics Engineering (VLSI)",
     "Materials and Metallurgical Engineering",
     "Mathematics and Computing",
-    "Bachelor of Design (B.Des)",
+    "Mechanical Engineering",
+    "Production & Industrial Engineering",
 ];
 
 export const APPLICATION_QUESTIONS = [
@@ -47,29 +48,72 @@ export const APPLICATION_QUESTIONS = [
     },
 ];
 
-const createEmptyResponses = () =>
-    APPLICATION_QUESTIONS.reduce(
-        (acc, question) => {
-            acc[question.id] = "";
-            return acc;
-        },
-        {} as Record<string, string>
-    );
+const createEmptyResponses =
+    () =>
+        APPLICATION_QUESTIONS.reduce(
+            (
+                acc,
+                question
+            ) => {
+                acc[
+                    question.id
+                ] = "";
+
+                return acc;
+            },
+            {} as Record<
+                string,
+                string
+            >
+        );
+
+type FormState = {
+    name: string;
+    phone: string;
+    sid: string;
+    branch: string;
+
+    gender:
+        | ""
+        | "male"
+        | "female";
+
+    /*
+     * null = not selected
+     * true = Yes
+     * false = No
+     */
+    isHostellers:
+        | boolean
+        | null;
+
+    responses: Record<
+        string,
+        string
+    >;
+};
 
-const initialForm = {
+const initialForm: FormState = {
     name: "",
     phone: "",
     sid: "",
     branch: "",
+    gender: "",
+    isHostellers: null,
     responses:
         createEmptyResponses(),
 };
 
 export default function ApplicationForm() {
     const [form, setForm] =
-        useState(initialForm);
+        useState<FormState>(
+            initialForm
+        );
 
-    const [application, setApplication] =
+    const [
+        application,
+        setApplication,
+    ] =
         useState<ApplicantType | null>(
             null
         );
@@ -82,8 +126,10 @@ export default function ApplicationForm() {
     const [error, setError] =
         useState("");
 
-    const [submitting, setSubmitting] =
-        useState(false);
+    const [
+        submitting,
+        setSubmitting,
+    ] = useState(false);
 
     const [
         savingPersonalInfo,
@@ -92,31 +138,43 @@ export default function ApplicationForm() {
 
     /*
      * ---------------------------------------------------------
-     * Field helpers
+     * Field helper
      * ---------------------------------------------------------
      */
 
-    const updateField = (
-        field: keyof typeof initialForm,
-        value: string
+    const updateField = <
+        K extends Exclude<
+            keyof FormState,
+            "responses"
+        >
+    >(
+        field: K,
+        value: FormState[K]
     ) => {
-        setForm((current) => ({
-            ...current,
-            [field]: value,
-        }));
+        setForm(
+            (current) => ({
+                ...current,
+                [field]: value,
+            })
+        );
     };
 
     const updateResponse = (
         questionId: string,
         value: string
     ) => {
-        setForm((current) => ({
-            ...current,
-            responses: {
-                ...current.responses,
-                [questionId]: value,
-            },
-        }));
+        setForm(
+            (current) => ({
+                ...current,
+
+                responses: {
+                    ...current.responses,
+
+                    [questionId]:
+                        value,
+                },
+            })
+        );
     };
 
     /*
@@ -146,15 +204,27 @@ export default function ApplicationForm() {
                         name:
                             existing.name ||
                             "",
+
                         phone:
                             existing.phone ||
                             "",
+
                         sid:
                             existing.sid ||
                             "",
+
                         branch:
                             existing.branch ||
                             "",
+
+                        gender:
+                            existing.gender ||
+                            "",
+
+                        isHostellers:
+                            existing.isHostellers ??
+                            null,
+
                         responses:
                             existing.responses ||
                             createEmptyResponses(),
@@ -175,162 +245,228 @@ export default function ApplicationForm() {
 
     /*
      * ---------------------------------------------------------
-     * Create new application
+     * Submit new application
      * ---------------------------------------------------------
      */
 
-    const handleSubmit = async (
-        event: React.FormEvent<HTMLFormElement>
-    ) => {
-        event.preventDefault();
+    const handleSubmit =
+        async (
+            event: React.FormEvent<HTMLFormElement>
+        ) => {
+            event.preventDefault();
 
-        setError("");
+            setError("");
 
-        const name =
-            form.name.trim();
+            const name =
+                form.name.trim();
 
-        const phone =
-            form.phone.trim();
+            const phone =
+                form.phone.trim();
 
-        const sid =
-            form.sid.trim();
+            const sid =
+                form.sid.trim();
 
-        const branch =
-            form.branch;
+            const branch =
+                form.branch;
 
-        if (
-            !name ||
-            !phone ||
-            !sid ||
-            !branch
-        ) {
-            setError(
-                "Please fill in all the required personal fields."
-            );
+            const gender =
+                form.gender;
 
-            return;
-        }
+            const isHostellers =
+                form.isHostellers;
 
-        if (
-            !/^[6-9]\d{9}$/.test(
-                phone
-            )
-        ) {
-            setError(
-                "Please enter a valid 10-digit phone number."
-            );
+            /*
+             * Required fields
+             *
+             * Do NOT use !isHostellers.
+             * false is a valid value.
+             */
 
-            return;
-        }
+            if (
+                !name ||
+                !phone ||
+                !sid ||
+                !branch ||
+                !gender ||
+                isHostellers ===
+                    null
+            ) {
+                setError(
+                    "Please fill in all the required personal fields."
+                );
 
-        if (
-            !/^\d{8}$/.test(sid)
-        ) {
-            setError(
-                "SID must be exactly 8 digits."
-            );
+                return;
+            }
 
-            return;
-        }
+            /*
+             * Phone
+             */
 
-        const missingResponses =
-            APPLICATION_QUESTIONS.some(
-                (question) =>
-                    !form.responses[
-                        question.id
-                    ].trim()
-            );
+            if (
+                !/^[6-9]\d{9}$/.test(
+                    phone
+                )
+            ) {
+                setError(
+                    "Please enter a valid 10-digit phone number."
+                );
 
-        if (missingResponses) {
-            setError(
-                "Please answer all the application questions."
-            );
+                return;
+            }
 
-            return;
-        }
+            /*
+             * SID
+             */
 
-        const trimmedResponses =
-            Object.keys(
-                form.responses
-            ).reduce(
-                (acc, key) => {
-                    acc[key] =
-                        form.responses[
-                            key
-                        ].trim();
+            if (
+                !/^\d{8}$/.test(
+                    sid
+                )
+            ) {
+                setError(
+                    "SID must be exactly 8 digits."
+                );
 
-                    return acc;
-                },
-                {} as Record<
-                    string,
-                    string
-                >
-            );
+                return;
+            }
 
-        setSubmitting(true);
+            /*
+             * Questions
+             */
 
-        try {
-            const result =
-                await createApplicant(
-                    name,
-                    sid,
-                    phone,
-                    branch,
-                    trimmedResponses
+            const missingResponses =
+                APPLICATION_QUESTIONS.some(
+                    (question) =>
+                        !form.responses[
+                            question.id
+                        ].trim()
                 );
 
-            if (!result.success) {
-                if (
-                    result.reason ===
-                    "duplicate"
-                ) {
-                    setError(
-                        "You have already submitted an application."
-                    );
-                } else {
-                    setError(
-                        "We could not submit your application. Please try again."
-                    );
-                }
+            if (
+                missingResponses
+            ) {
+                setError(
+                    "Please answer all the application questions."
+                );
 
                 return;
             }
 
-            setApplication(
-                result.applicant
-            );
+            /*
+             * Trim responses
+             */
+
+            const trimmedResponses =
+                Object.keys(
+                    form.responses
+                ).reduce(
+                    (
+                        acc,
+                        key
+                    ) => {
+                        acc[key] =
+                            form.responses[
+                                key
+                            ].trim();
+
+                        return acc;
+                    },
+                    {} as Record<
+                        string,
+                        string
+                    >
+                );
+
+            setSubmitting(true);
 
-            setForm({
-                name:
-                    result.applicant.name ||
-                    "",
-                phone:
-                    result.applicant.phone ||
-                    "",
-                sid:
-                    result.applicant.sid ||
-                    "",
-                branch:
-                    result.applicant.branch ||
-                    "",
-                responses:
+            try {
+                const result =
+                    await createApplicant(
+                        name,
+                        sid,
+                        phone,
+                        branch,
+                        gender,
+                        isHostellers,
+                        trimmedResponses
+                    );
+
+                if (
+                    !result.success
+                ) {
+                    if (
+                        result.reason ===
+                        "duplicate"
+                    ) {
+                        setError(
+                            "You have already submitted an application."
+                        );
+                    } else {
+                        setError(
+                            "We could not submit your application. Please try again."
+                        );
+                    }
+
+                    return;
+                }
+
+                setApplication(
                     result.applicant
-                        .responses ||
-                    createEmptyResponses(),
-            });
-        } catch (submissionError) {
-            console.error(
-                "Unexpected application submission error:",
-                submissionError
-            );
+                );
 
-            setError(
-                "We could not submit your application. Please try again."
-            );
-        } finally {
-            setSubmitting(false);
-        }
-    };
+                setForm({
+                    name:
+                        result
+                            .applicant
+                            .name ||
+                        "",
+
+                    phone:
+                        result
+                            .applicant
+                            .phone ||
+                        "",
+
+                    sid:
+                        result
+                            .applicant
+                            .sid ||
+                        "",
+
+                    branch:
+                        result
+                            .applicant
+                            .branch ||
+                        "",
+
+                    gender:
+                        result
+                            .applicant
+                            .gender ||
+                        "",
+
+                    isHostellers:
+                        result
+                            .applicant
+                            .isHostellers ??
+                        null,
+
+                    responses:
+                        result
+                            .applicant
+                            .responses ||
+                        createEmptyResponses(),
+                });
+            } catch {
+                setError(
+                    "We could not submit your application. Please try again."
+                );
+            } finally {
+                setSubmitting(
+                    false
+                );
+            }
+        };
 
     /*
      * ---------------------------------------------------------
@@ -358,11 +494,20 @@ export default function ApplicationForm() {
             const branch =
                 form.branch;
 
+            const gender =
+                form.gender;
+
+            const isHostellers =
+                form.isHostellers;
+
             if (
                 !name ||
                 !phone ||
                 !sid ||
-                !branch
+                !branch ||
+                !gender ||
+                isHostellers ===
+                    null
             ) {
                 setError(
                     "Please fill in all the personal information."
@@ -384,7 +529,9 @@ export default function ApplicationForm() {
             }
 
             if (
-                !/^\d{8}$/.test(sid)
+                !/^\d{8}$/.test(
+                    sid
+                )
             ) {
                 setError(
                     "SID must be exactly 8 digits."
@@ -404,10 +551,14 @@ export default function ApplicationForm() {
                         name,
                         phone,
                         sid,
-                        branch
+                        branch,
+                        gender,
+                        isHostellers
                     );
 
-                if (!result.success) {
+                if (
+                    !result.success
+                ) {
                     setError(
                         result.reason ===
                             "not_found"
@@ -423,30 +574,47 @@ export default function ApplicationForm() {
                 );
 
                 setForm(
-                    (current) => ({
+                    (
+                        current
+                    ) => ({
                         ...current,
+
                         name:
-                            result.applicant
+                            result
+                                .applicant
                                 .name,
+
                         phone:
-                            result.applicant
+                            result
+                                .applicant
                                 .phone ||
                             "",
+
                         sid:
-                            result.applicant
+                            result
+                                .applicant
                                 .sid,
+
                         branch:
-                            result.applicant
+                            result
+                                .applicant
                                 .branch ||
                             "",
+
+                        gender:
+                            result
+                                .applicant
+                                .gender ||
+                            "",
+
+                        isHostellers:
+                            result
+                                .applicant
+                                .isHostellers ??
+                            null,
                     })
                 );
-            } catch (updateError) {
-                console.error(
-                    "Error updating personal information:",
-                    updateError
-                );
-
+            } catch {
                 setError(
                     "Could not update your personal information. Please try again."
                 );
@@ -459,11 +627,13 @@ export default function ApplicationForm() {
 
     /*
      * ---------------------------------------------------------
-     * Loading state
+     * Loading
      * ---------------------------------------------------------
      */
 
-    if (checkingApplication) {
+    if (
+        checkingApplication
+    ) {
         return (
             <div className="mx-auto max-w-3xl rounded-xl border bg-white p-8 text-center shadow-sm">
                 <p className="text-sm text-muted-foreground">
@@ -486,7 +656,6 @@ export default function ApplicationForm() {
 
         return (
             <div className="mx-auto max-w-3xl space-y-8">
-                {/* Personal Information */}
                 <div className="rounded-xl border bg-white p-6 shadow-sm">
                     <div className="flex items-start justify-between gap-4">
                         <div>
@@ -525,6 +694,7 @@ export default function ApplicationForm() {
 
                     <div className="mt-6 space-y-6">
                         {/* Name + Phone */}
+
                         <div className="grid gap-6 md:grid-cols-2">
                             <div className="space-y-2">
                                 <label
@@ -595,6 +765,7 @@ export default function ApplicationForm() {
                         </div>
 
                         {/* SID + Branch */}
+
                         <div className="grid gap-6 md:grid-cols-2">
                             <div className="space-y-2">
                                 <label
@@ -686,6 +857,109 @@ export default function ApplicationForm() {
                             </div>
                         </div>
 
+                        {/* Gender + Hosteller */}
+
+                        <div className="grid gap-6 md:grid-cols-2">
+                            <div className="space-y-2">
+                                <label
+                                    htmlFor="existing-gender"
+                                    className="text-sm font-medium"
+                                >
+                                    Gender
+                                </label>
+
+                                <select
+                                    id="existing-gender"
+                                    value={
+                                        form.gender
+                                    }
+                                    disabled={
+                                        !canEdit
+                                    }
+                                    onChange={(
+                                        event
+                                    ) =>
+                                        updateField(
+                                            "gender",
+                                            event
+                                                .target
+                                                .value as
+                                                | ""
+                                                | "male"
+                                                | "female"
+                                        )
+                                    }
+                                    className="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm outline-none disabled:cursor-not-allowed disabled:opacity-60"
+                                >
+                                    <option value="">
+                                        Select your gender
+                                    </option>
+
+                                    <option value="male">
+                                        Male
+                                    </option>
+
+                                    <option value="female">
+                                        Female
+                                    </option>
+                                </select>
+                            </div>
+
+                            <div className="space-y-2">
+                                <label
+                                    htmlFor="existing-isHostellers"
+                                    className="text-sm font-medium"
+                                >
+                                    Are you a hosteller?
+                                </label>
+
+                                <select
+                                    id="existing-isHostellers"
+                                    value={
+                                        form.isHostellers ===
+                                        null
+                                            ? ""
+                                            : String(
+                                                  form.isHostellers
+                                              )
+                                    }
+                                    disabled={
+                                        !canEdit
+                                    }
+                                    onChange={(
+                                        event
+                                    ) => {
+                                        const value =
+                                            event
+                                                .target
+                                                .value;
+
+                                        updateField(
+                                            "isHostellers",
+                                            value ===
+                                                ""
+                                                ? null
+                                                : value ===
+                                                    "true"
+                                        );
+                                    }}
+                                    className="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm outline-none disabled:cursor-not-allowed disabled:opacity-60"
+                                >
+                                    <option value="">
+                                        Select an option
+                                    </option>
+
+                                    <option value="true">
+                                        Yes
+                                    </option>
+
+                                    <option value="false">
+                                        No
+                                    </option>
+                                </select>
+                            </div>
+                        </div>
+
                         {canEdit && (
                             <button
                                 type="button"
@@ -705,15 +979,15 @@ export default function ApplicationForm() {
                     </div>
                 </div>
 
-                {/* Read-only answers */}
+                {/* Submitted answers */}
+
                 <div className="rounded-xl border bg-white p-6 shadow-sm">
                     <h2 className="text-xl font-semibold">
                         Submitted Application
                     </h2>
 
                     <p className="mt-1 text-sm text-muted-foreground">
-                        Your submitted answers
-                        cannot be changed.
+                        Your submitted answers cannot be changed.
                     </p>
 
                     <div className="mt-6 space-y-7">
@@ -765,16 +1039,19 @@ export default function ApplicationForm() {
 
     /*
      * ---------------------------------------------------------
-     * New application form
+     * New application
      * ---------------------------------------------------------
      */
 
     return (
         <form
-            onSubmit={handleSubmit}
+            onSubmit={
+                handleSubmit
+            }
             className="mx-auto max-w-3xl space-y-8"
         >
             {/* Personal Information */}
+
             <div className="rounded-xl border bg-white p-6 shadow-sm">
                 <h2 className="text-xl font-semibold">
                     Personal Information
@@ -786,6 +1063,7 @@ export default function ApplicationForm() {
 
                 <div className="mt-6 space-y-6">
                     {/* Name + Phone */}
+
                     <div className="grid gap-6 md:grid-cols-2">
                         <div className="space-y-2">
                             <label
@@ -852,6 +1130,7 @@ export default function ApplicationForm() {
                     </div>
 
                     {/* SID + Branch */}
+
                     <div className="grid gap-6 md:grid-cols-2">
                         <div className="space-y-2">
                             <label
@@ -937,10 +1216,108 @@ export default function ApplicationForm() {
                             </select>
                         </div>
                     </div>
+
+                    {/* Gender + Hosteller */}
+
+                    <div className="grid gap-6 md:grid-cols-2">
+                        <div className="space-y-2">
+                            <label
+                                htmlFor="gender"
+                                className="text-sm font-medium"
+                            >
+                                Gender
+                            </label>
+
+                            <select
+                                id="gender"
+                                value={
+                                    form.gender
+                                }
+                                onChange={(
+                                    event
+                                ) =>
+                                    updateField(
+                                        "gender",
+                                        event
+                                            .target
+                                            .value as
+                                            | ""
+                                            | "male"
+                                            | "female"
+                                    )
+                                }
+                                className="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm outline-none"
+                            >
+                                <option value="">
+                                    Select your gender
+                                </option>
+
+                                <option value="male">
+                                    Male
+                                </option>
+
+                                <option value="female">
+                                    Female
+                                </option>
+                            </select>
+                        </div>
+
+                        <div className="space-y-2">
+                            <label
+                                htmlFor="isHostellers"
+                                className="text-sm font-medium"
+                            >
+                                Are you a hosteller?
+                            </label>
+
+                            <select
+                                id="isHostellers"
+                                value={
+                                    form.isHostellers ===
+                                    null
+                                        ? ""
+                                        : String(
+                                              form.isHostellers
+                                          )
+                                }
+                                onChange={(
+                                    event
+                                ) => {
+                                    const value =
+                                        event
+                                            .target
+                                            .value;
+
+                                    updateField(
+                                        "isHostellers",
+                                        value ===
+                                            ""
+                                            ? null
+                                            : value ===
+                                                "true"
+                                    );
+                                }}
+                                className="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm outline-none"
+                            >
+                                <option value="">
+                                    Select an option
+                                </option>
+
+                                <option value="true">
+                                    Yes
+                                </option>
+
+                                <option value="false">
+                                    No
+                                </option>
+                            </select>
+                        </div>
+                    </div>
                 </div>
             </div>
 
             {/* Questions */}
+
             <div className="rounded-xl border bg-white p-6 shadow-sm">
                 <h2 className="text-xl font-semibold">
                     Application Questions
@@ -989,7 +1366,9 @@ export default function ApplicationForm() {
 
             <button
                 type="submit"
-                disabled={submitting}
+                disabled={
+                    submitting
+                }
                 className="w-full rounded-md bg-primary px-6 py-3 text-sm font-medium text-primary-foreground transition-opacity hover:opacity-90 disabled:cursor-not-allowed disabled:opacity-50"
             >
                 {submitting
@@ -1031,7 +1410,9 @@ function Question({
             <textarea
                 id={number}
                 value={value}
-                onChange={(event) =>
+                onChange={(
+                    event
+                ) =>
                     onChange(
                         event.target.value
                     )
diff --git a/src/lib/supabase/actions/applicants.actions.ts b/src/lib/supabase/actions/applicants.actions.ts
index 0957bf5..6a998de 100644
--- a/src/lib/supabase/actions/applicants.actions.ts
+++ b/src/lib/supabase/actions/applicants.actions.ts
@@ -13,26 +13,85 @@ export type CreateApplicantResult =
 
 /*
  * ---------------------------------------------------------
- * Shared applicant mapper
+ * Refresh interview schedule
+ * ---------------------------------------------------------
+ *
+ * The scheduler always rebuilds the schedule from the
+ * current PENDING applicant pool in Supabase.
+ *
+ * IMPORTANT:
+ * A failure here must never make an otherwise successful
+ * application/update/decision operation fail.
+ */
+
+const requestInterviewSchedule =
+    async (): Promise<void> => {
+        try {
+            const {
+                error,
+            } =
+                await client.functions.invoke(
+                    "schedule-interviews",
+                    {
+                        body: {},
+                    }
+                );
+
+            if (error) {
+                console.error(
+                    "Interview schedule refresh failed:",
+                    error
+                );
+            }
+        } catch (error) {
+            console.error(
+                "Interview schedule refresh failed:",
+                error
+            );
+        }
+    };
+
+/*
+ * ---------------------------------------------------------
+ * Map database applicant to ApplicantType
  * ---------------------------------------------------------
  */
 
-const mapApplicant = (item: any): ApplicantType => {
-    const response = item.applicant_response;
+const mapApplicant = (
+    item: any
+): ApplicantType => {
+    const response =
+        item.applicant_response;
 
-    const responseData = Array.isArray(response)
-        ? response[0]
-        : response;
+    const responseData =
+        Array.isArray(response)
+            ? response[0]
+            : response;
 
     return {
         ...item,
-        userId: item.userId,
-        status: item.status?.toLowerCase(),
+
+        userId:
+            item.userId,
+
+        status:
+            item.status?.toLowerCase(),
+
         createdAt:
             item.createdAt ||
             item.created_at,
-        branch: responseData?.branch,
-        responses: responseData?.responses,
+
+        gender:
+            item.gender ?? null,
+
+        isHostellers:
+            item.isHostellers ?? null,
+
+        branch:
+            responseData?.branch,
+
+        responses:
+            responseData?.responses,
     } as ApplicantType;
 };
 
@@ -42,54 +101,69 @@ const mapApplicant = (item: any): ApplicantType => {
  * ---------------------------------------------------------
  */
 
-export const fetchApplicants = async (): Promise<
-    ApplicantType[]
-> => {
-    const { data, error } = await client
-        .from("applicants")
-        .select(
-            "*, applicant_response(branch, responses)"
-        )
-        .order("created_at", {
-            ascending: false,
-        });
-
-    if (error) {
-        console.error(
-            "Error fetching applicants:",
-            error
-        );
+export const fetchApplicants =
+    async (): Promise<
+        ApplicantType[]
+    > => {
+        const {
+            data,
+            error,
+        } = await client
+            .from("applicants")
+            .select(
+                "*, applicant_response(branch, responses)"
+            )
+            .order(
+                "created_at",
+                {
+                    ascending: false,
+                }
+            );
 
-        return [];
-    }
+        if (error) {
+            console.error(
+                "Error fetching applicants:",
+                error
+            );
 
-    return (data as any[]).map(mapApplicant);
-};
+            return [];
+        }
+
+        return (
+            (data as any[]) || []
+        ).map(mapApplicant);
+    };
 
 /*
  * ---------------------------------------------------------
- * Fetch one applicant with complete responses
+ * Fetch applicant with responses
  * ---------------------------------------------------------
  */
 
 export const fetchApplicantWithResponses =
     async (
         id: string
-    ): Promise<ApplicantType | null> => {
-        const { data, error } = await client
+    ): Promise<
+        ApplicantType | null
+    > => {
+        const {
+            data,
+            error,
+        } = await client
             .from("applicants")
             .select(
                 "*, applicant_response(branch, responses)"
             )
-            .eq("id", id)
+            .eq(
+                "id",
+                id
+            )
             .single();
 
-        if (error) {
-            console.error(
-                "Error fetching applicant with responses:",
-                error
-            );
-
+        if (
+            error ||
+            !data
+        ) {
             return null;
         }
 
@@ -98,39 +172,47 @@ export const fetchApplicantWithResponses =
 
 /*
  * ---------------------------------------------------------
- * Fetch currently logged-in user's application
+ * Fetch current user's application
  * ---------------------------------------------------------
  */
 
 export const fetchMyApplication =
-    async (): Promise<ApplicantType | null> => {
+    async (): Promise<
+        ApplicantType | null
+    > => {
         const {
-            data: { user },
+            data: {
+                user,
+            },
             error: userError,
-        } = await client.auth.getUser();
+        } =
+            await client.auth.getUser();
 
-        if (userError || !user) {
+        if (
+            userError ||
+            !user
+        ) {
             return null;
         }
 
-        const { data, error } = await client
+        const {
+            data,
+            error,
+        } = await client
             .from("applicants")
             .select(
                 "*, applicant_response(branch, responses)"
             )
-            .eq("userId", user.id)
+            .eq(
+                "userId",
+                user.id
+            )
             .maybeSingle();
 
-        if (error) {
-            console.error(
-                "Error fetching current user's application:",
-                error
-            );
-
-            return null;
-        }
-
-        if (!data) {
+        if (
+            error ||
+            !data
+        ) {
             return null;
         }
 
@@ -139,307 +221,380 @@ export const fetchMyApplication =
 
 /*
  * ---------------------------------------------------------
- * Create a walk-in applicant
+ * Create walk-in applicant
  * ---------------------------------------------------------
- *
- * Walk-ins are not associated with a logged-in user.
  */
 
-export const createWalkIn = async (
-    name: string,
-    sid: string,
-    phone: string
-): Promise<ApplicantType | null> => {
-    const { data, error } = await client
-        .from("applicants")
-        .insert([
-            {
-                name,
-                sid,
-                phone: phone || null,
-                isWalkin: true,
-                status: "PENDING",
-            },
-        ])
-        .select()
-        .single();
-
-    if (error) {
-        console.error(
-            "Error creating walk-in:",
-            error
-        );
+export const createWalkIn =
+    async (
+        name: string,
+        sid: string,
+        phone: string
+    ): Promise<
+        ApplicantType | null
+    > => {
+        const {
+            data,
+            error,
+        } = await client
+            .from("applicants")
+            .insert([
+                {
+                    name,
+                    sid,
+                    phone:
+                        phone || null,
+                    isWalkin:
+                        true,
+                    status:
+                        "PENDING",
+                },
+            ])
+            .select()
+            .single();
 
-        return null;
-    }
+        if (
+            error ||
+            !data
+        ) {
+            return null;
+        }
 
-    return {
-        ...data,
-        status:
-            data.status?.toLowerCase(),
-        createdAt:
-            data.createdAt ||
-            data.created_at,
-    } as ApplicantType;
-};
+        return mapApplicant(
+            data
+        );
+    };
 
 /*
  * ---------------------------------------------------------
- * Create a normal application
+ * Create normal applicant
  * ---------------------------------------------------------
- *
- * One authenticated account can have only one application.
- *
- * This is enforced by the unique userId constraint in
- * Supabase. The pre-check below is only for a better UX.
  */
 
-export const createApplicant = async (
-    name: string,
-    sid: string,
-    phone: string,
-    branch: string,
-    responses: Record<string, string>
-): Promise<CreateApplicantResult> => {
-    /*
-     * 1. Get authenticated user
-     */
-
-    const {
-        data: { user },
-        error: userError,
-    } = await client.auth.getUser();
-
-    if (userError || !user) {
-        console.error(
-            "Cannot create application without an authenticated user:",
-            userError
-        );
+export const createApplicant =
+    async (
+        name: string,
+        sid: string,
+        phone: string,
+        branch: string,
+        gender:
+            | "male"
+            | "female",
+        isHostellers: boolean,
+        responses: Record<
+            string,
+            string
+        >
+    ): Promise<
+        CreateApplicantResult
+    > => {
+        /*
+         * Get logged-in user.
+         */
 
-        return {
-            success: false,
-            reason: "error",
-        };
-    }
-
-    /*
-     * 2. Friendly existing-application check
-     */
-
-    const {
-        data: existingApplicant,
-        error: existingApplicantError,
-    } = await client
-        .from("applicants")
-        .select("id")
-        .eq("userId", user.id)
-        .maybeSingle();
-
-    if (existingApplicantError) {
-        console.error(
-            "Error checking existing application:",
-            existingApplicantError
-        );
+        const {
+            data: {
+                user,
+            },
+            error: userError,
+        } =
+            await client.auth.getUser();
 
-        return {
-            success: false,
-            reason: "error",
-        };
-    }
+        if (
+            userError ||
+            !user
+        ) {
+            console.error(
+                "Cannot create application without an authenticated user:",
+                userError
+            );
 
-    if (existingApplicant) {
-        return {
-            success: false,
-            reason: "duplicate",
-        };
-    }
-
-    /*
-     * 3. Create applicant
-     */
-
-    const {
-        data: applicantData,
-        error: applicantError,
-    } = await client
-        .from("applicants")
-        .insert([
-            {
-                userId: user.id,
-                name,
-                sid,
-                phone: phone || null,
-                isWalkin: false,
-                status: "PENDING",
-            },
-        ])
-        .select()
-        .single();
+            return {
+                success: false,
+                reason: "error",
+            };
+        }
 
-    if (applicantError) {
         /*
-         * PostgreSQL unique constraint violation.
-         * This is the definitive one-account-one-application
-         * protection.
+         * Check whether this account has already
+         * submitted an application.
          */
-        if (applicantError.code === "23505") {
+
+        const {
+            data:
+                existingApplicant,
+            error:
+                existingApplicantError,
+        } = await client
+            .from("applicants")
+            .select("id")
+            .eq(
+                "userId",
+                user.id
+            )
+            .maybeSingle();
+
+        if (
+            existingApplicantError
+        ) {
             console.error(
-                "Duplicate application:",
-                applicantError
+                "Error checking existing application:",
+                existingApplicantError
             );
 
+            return {
+                success: false,
+                reason: "error",
+            };
+        }
+
+        if (
+            existingApplicant
+        ) {
             return {
                 success: false,
                 reason: "duplicate",
             };
         }
 
-        console.error(
-            "Error creating applicant:",
-            applicantError
-        );
+        /*
+         * Create applicant.
+         */
+
+        const {
+            data:
+                applicantData,
+            error:
+                applicantError,
+        } = await client
+            .from("applicants")
+            .insert([
+                {
+                    userId:
+                        user.id,
+
+                    name,
+
+                    sid,
+
+                    phone:
+                        phone || null,
+
+                    gender,
+
+                    isHostellers,
+
+                    isWalkin:
+                        false,
+
+                    status:
+                        "PENDING",
+                },
+            ])
+            .select()
+            .single();
 
-        console.error(
-            "Error details:",
-            {
-                message:
-                    applicantError.message,
-                details:
-                    applicantError.details,
-                hint:
-                    applicantError.hint,
-                code:
-                    applicantError.code,
+        if (
+            applicantError ||
+            !applicantData
+        ) {
+            /*
+             * Unique userId constraint means this is
+             * already a submitted account.
+             */
+            if (
+                applicantError?.code ===
+                "23505"
+            ) {
+                return {
+                    success: false,
+                    reason: "duplicate",
+                };
             }
-        );
 
-        return {
-            success: false,
-            reason: "error",
-        };
-    }
-
-    /*
-     * 4. Store application responses
-     */
-
-    const {
-        error: responseError,
-    } = await client
-        .from("applicant_response")
-        .insert([
-            {
-                applicantId:
-                    applicantData.id,
-                branch,
-                responses,
-            },
-        ]);
+            console.error(
+                "Error creating applicant:",
+                applicantError
+            );
+
+            return {
+                success: false,
+                reason: "error",
+            };
+        }
+
+        /*
+         * Store branch + answers.
+         */
+
+        const {
+            error:
+                responseError,
+        } = await client
+            .from(
+                "applicant_response"
+            )
+            .insert([
+                {
+                    applicantId:
+                        applicantData.id,
+
+                    branch,
 
-    if (responseError) {
-        console.error(
-            "Error creating applicant response:",
+                    responses,
+                },
+            ]);
+
+        if (
             responseError
-        );
+        ) {
+            console.error(
+                "Error creating applicant response:",
+                responseError
+            );
 
-        await client
-            .from("applicants")
-            .delete()
-            .eq(
-                "id",
-                applicantData.id
+            /*
+             * Roll back applicant if the response
+             * record could not be created.
+             */
+            await client
+                .from(
+                    "applicants"
+                )
+                .delete()
+                .eq(
+                    "id",
+                    applicantData.id
+                );
+
+            return {
+                success: false,
+                reason: "error",
+            };
+        }
+
+        /*
+         * Sync application to Google Sheets.
+         *
+         * Supabase remains the source of truth, so a
+         * Google Sheets failure does not invalidate the
+         * successful application.
+         */
+
+        try {
+            const {
+                error:
+                    sheetsError,
+            } =
+                await client.functions.invoke(
+                    "sync-application-to-sheets",
+                    {
+                        body: {
+                            operation:
+                                "application",
+
+                            applicationId:
+                                applicantData.id,
+
+                            name,
+
+                            phone,
+
+                            sid,
+
+                            branch,
+
+                            gender,
+
+                            isHostellers,
+
+                            q1:
+                                responses.Q1 ||
+                                "",
+
+                            q2:
+                                responses.Q2 ||
+                                "",
+
+                            q3:
+                                responses.Q3 ||
+                                "",
+
+                            q4:
+                                responses.Q4 ||
+                                "",
+                        },
+                    }
+                );
+
+            if (
+                sheetsError
+            ) {
+                console.error(
+                    "Application saved to Supabase, but Google Sheets synchronization failed:",
+                    sheetsError
+                );
+            }
+        } catch (error) {
+            console.error(
+                "Application saved to Supabase, but Google Sheets synchronization failed:",
+                error
             );
+        }
+
+        /*
+         * Refresh interview schedule.
+         *
+         * The new applicant is now part of the PENDING
+         * pool and may change:
+         * - panel count
+         * - day count
+         * - priority ordering
+         */
+        await requestInterviewSchedule();
 
         return {
-            success: false,
-            reason: "error",
-        };
-    }
+            success: true,
 
-    /*
-     * 5. Sync application to Google Sheets
-     */
+            applicant: {
+                ...applicantData,
 
-    const {
-        data: sheetsData,
-        error: sheetsError,
-    } = await client.functions.invoke(
-        "sync-application-to-sheets",
-        {
-            body: {
-                operation: "application",
+                userId:
+                    applicantData.userId,
 
-                applicationId:
-                    applicantData.id,
+                status:
+                    applicantData.status?.toLowerCase(),
 
-                name,
-                phone,
-                sid,
-                branch,
+                createdAt:
+                    applicantData.createdAt ||
+                    applicantData.created_at,
 
-                q1:
-                    responses.Q1 || "",
-                q2:
-                    responses.Q2 || "",
-                q3:
-                    responses.Q3 || "",
-                q4:
-                    responses.Q4 || "",
-            },
-        }
-    );
+                branch,
 
-    /*
-     * Supabase is the source of truth.
-     * Sheets failure does not invalidate the application.
-     */
+                gender,
 
-    if (sheetsError) {
-        console.error(
-            "Application saved to Supabase, but Google Sheets synchronization failed:",
-            sheetsError
-        );
-    } else if (
-        sheetsData?.success === false
-    ) {
-        console.error(
-            "Google Sheets synchronization failed:",
-            sheetsData
-        );
-    }
+                isHostellers,
 
-    return {
-        success: true,
-
-        applicant: {
-            ...applicantData,
-            userId: user.id,
-            status:
-                applicantData.status?.toLowerCase(),
-            createdAt:
-                applicantData.createdAt ||
-                applicantData.created_at,
-            branch,
-            responses,
-        } as ApplicantType,
+                responses,
+            } as ApplicantType,
+        };
     };
-};
 
 /*
  * ---------------------------------------------------------
- * Update personal information for the logged-in applicant
+ * Update applicant personal information
  * ---------------------------------------------------------
  *
- * Editable:
- * - name
- * - phone
- * - sid
- * - branch
+ * Editable while PENDING:
  *
- * Never editable here:
- * - application responses
+ * - Name
+ * - Phone
+ * - SID
+ * - Branch
+ * - Gender
+ * - Hosteller / Day Scholar
  *
- * Only PENDING applications can use this function.
+ * Application answers remain untouched.
  */
 
 export const updateApplicantPersonalInfo =
@@ -448,7 +603,11 @@ export const updateApplicantPersonalInfo =
         name: string,
         phone: string,
         sid: string,
-        branch: string
+        branch: string,
+        gender:
+            | "male"
+            | "female",
+        isHostellers: boolean
     ): Promise<
         | {
               success: true;
@@ -462,11 +621,17 @@ export const updateApplicantPersonalInfo =
           }
     > => {
         const {
-            data: { user },
+            data: {
+                user,
+            },
             error: userError,
-        } = await client.auth.getUser();
+        } =
+            await client.auth.getUser();
 
-        if (userError || !user) {
+        if (
+            userError ||
+            !user
+        ) {
             return {
                 success: false,
                 reason: "error",
@@ -474,12 +639,10 @@ export const updateApplicantPersonalInfo =
         }
 
         /*
-         * Main applicant fields.
-         *
-         * userId + applicantId + PENDING means the
-         * authenticated user can only update their own
+         * Update only the authenticated user's own
          * still-pending application.
          */
+
         const {
             data,
             error,
@@ -487,18 +650,37 @@ export const updateApplicantPersonalInfo =
             .from("applicants")
             .update({
                 name,
-                phone: phone || null,
+
+                phone:
+                    phone || null,
+
                 sid,
+
+                gender,
+
+                isHostellers,
             })
-            .eq("id", applicantId)
-            .eq("userId", user.id)
-            .eq("status", "PENDING")
+            .eq(
+                "id",
+                applicantId
+            )
+            .eq(
+                "userId",
+                user.id
+            )
+            .eq(
+                "status",
+                "PENDING"
+            )
             .select()
             .single();
 
-        if (error || !data) {
+        if (
+            error ||
+            !data
+        ) {
             console.error(
-                "Error updating personal information:",
+                "Error updating applicant:",
                 error
             );
 
@@ -513,12 +695,17 @@ export const updateApplicantPersonalInfo =
         }
 
         /*
-         * Branch lives in applicant_response.
+         * Update branch separately because branch
+         * lives in applicant_response.
          */
+
         const {
-            error: branchError,
+            error:
+                branchError,
         } = await client
-            .from("applicant_response")
+            .from(
+                "applicant_response"
+            )
             .update({
                 branch,
             })
@@ -527,9 +714,11 @@ export const updateApplicantPersonalInfo =
                 applicantId
             );
 
-        if (branchError) {
+        if (
+            branchError
+        ) {
             console.error(
-                "Error updating applicant branch:",
+                "Error updating branch:",
                 branchError
             );
 
@@ -540,57 +729,87 @@ export const updateApplicantPersonalInfo =
         }
 
         /*
-         * Sync the updated personal information
-         * to the same application row in Google Sheets.
+         * Update the existing application row
+         * in Google Sheets.
          */
-        const {
-            data: sheetsData,
-            error: sheetsError,
-        } = await client.functions.invoke(
-            "sync-application-to-sheets",
-            {
-                body: {
-                    operation:
-                        "update_application",
-
-                    applicationId:
-                        applicantId,
 
-                    name,
-                    phone,
-                    sid,
-                    branch,
-                },
-            }
-        );
+        try {
+            const {
+                error:
+                    sheetsError,
+            } =
+                await client.functions.invoke(
+                    "sync-application-to-sheets",
+                    {
+                        body: {
+                            operation:
+                                "update_application",
 
-        if (sheetsError) {
-            console.error(
-                "Personal information updated in Supabase, but Google Sheets synchronization failed:",
+                            applicationId:
+                                applicantId,
+
+                            name,
+
+                            phone,
+
+                            sid,
+
+                            branch,
+
+                            gender,
+
+                            isHostellers,
+                        },
+                    }
+                );
+
+            if (
                 sheetsError
-            );
-        } else if (
-            sheetsData?.success === false
-        ) {
+            ) {
+                console.error(
+                    "Personal information saved to Supabase, but Google Sheets synchronization failed:",
+                    sheetsError
+                );
+            }
+        } catch (error) {
             console.error(
-                "Google Sheets personal information synchronization failed:",
-                sheetsData
+                "Personal information saved to Supabase, but Google Sheets synchronization failed:",
+                error
             );
         }
 
         /*
-         * Return complete updated applicant.
+         * Rebuild schedule because:
+         *
+         * - name can change in the shared sheet
+         * - SID can change in the shared sheet
+         * - gender can change priority
+         * - hosteller/day-scholar can change priority
+         */
+        await requestInterviewSchedule();
+
+        /*
+         * Fetch complete updated applicant.
          */
+
         const {
-            data: completeApplicant,
-            error: fetchError,
+            data:
+                completeApplicant,
+            error:
+                fetchError,
         } = await client
             .from("applicants")
             .select(
                 "*, applicant_response(branch, responses)"
             )
-            .eq("id", applicantId)
-            .eq("userId", user.id)
+            .eq(
+                "id",
+                applicantId
+            )
+            .eq(
+                "userId",
+                user.id
+            )
             .single();
 
         if (
@@ -605,6 +824,7 @@ export const updateApplicantPersonalInfo =
 
         return {
             success: true,
+
             applicant:
                 mapApplicant(
                     completeApplicant
@@ -614,192 +834,231 @@ export const updateApplicantPersonalInfo =
 
 /*
  * ---------------------------------------------------------
- * Existing generic applicant update
+ * Generic applicant update
  * ---------------------------------------------------------
  *
- * This function is preserved from master.
- *
- * It is intentionally separate from
- * updateApplicantPersonalInfo().
- *
- * This allows existing panelist/admin functionality to
- * continue working without changing its behavior.
+ * Existing admin/panelist functionality is preserved.
  */
 
-export const updateApplicant = async (
-    applicantId: string,
-    data: {
-        name: string;
-        sid: string;
-        phone: string;
-        remarks?: string;
-        branch?: string;
-        responses?: Record<string, string>;
-    }
-): Promise<ApplicantType | null> => {
-    /*
-     * Update main applicant record.
-     */
-
-    const {
-        error: applicantError,
-    } = await client
-        .from("applicants")
-        .update({
-            name: data.name.trim(),
-            sid: data.sid.trim(),
-            phone:
-                data.phone.trim() ||
-                null,
-            remarks:
-                data.remarks?.trim() ||
-                null,
-        })
-        .eq(
-            "id",
-            applicantId
-        );
-
-    if (applicantError) {
-        console.error(
-            "Error updating applicant:",
-            applicantError
-        );
-
-        return null;
-    }
-
-    /*
-     * Walk-ins do not normally have applicant_response.
-     *
-     * Only update/create applicant_response when
-     * branch or responses were supplied.
-     */
-    if (
-        data.branch !== undefined ||
-        data.responses !== undefined
-    ) {
+export const updateApplicant =
+    async (
+        applicantId: string,
+        data: {
+            name: string;
+            sid: string;
+            phone: string;
+            remarks?: string;
+            branch?: string;
+            gender?:
+                | "male"
+                | "female";
+            isHostellers?: boolean;
+            responses?: Record<
+                string,
+                string
+            >;
+        }
+    ): Promise<
+        ApplicantType | null
+    > => {
         const {
-            data: existingResponse,
-            error: responseFetchError,
+            error:
+                applicantError,
         } = await client
-            .from("applicant_response")
-            .select("id")
+            .from("applicants")
+            .update({
+                name:
+                    data.name.trim(),
+
+                sid:
+                    data.sid.trim(),
+
+                phone:
+                    data.phone.trim() ||
+                    null,
+
+                remarks:
+                    data.remarks?.trim() ||
+                    null,
+
+                ...(data.gender !==
+                undefined
+                    ? {
+                          gender:
+                              data.gender,
+                      }
+                    : {}),
+
+                ...(data.isHostellers !==
+                undefined
+                    ? {
+                          isHostellers:
+                              data.isHostellers,
+                      }
+                    : {}),
+            })
             .eq(
-                "applicantId",
+                "id",
                 applicantId
-            )
-            .limit(1)
-            .maybeSingle();
+            );
 
-        if (responseFetchError) {
+        if (
+            applicantError
+        ) {
             console.error(
-                "Error checking applicant response:",
-                responseFetchError
+                "Error updating applicant:",
+                applicantError
             );
 
             return null;
         }
 
         /*
-         * Existing response.
+         * Update applicant response if required.
          */
-        if (existingResponse) {
-            const responseUpdate: {
-                branch?: string;
-                responses?: Record<
-                    string,
-                    string
-                >;
-            } = {};
 
-            if (
-                data.branch !==
-                undefined
-            ) {
-                responseUpdate.branch =
-                    data.branch.trim();
-            }
-
-            if (
-                data.responses !==
+        if (
+            data.branch !==
+                undefined ||
+            data.responses !==
                 undefined
-            ) {
-                responseUpdate.responses =
-                    data.responses;
-            }
-
+        ) {
             const {
+                data:
+                    existingResponse,
                 error:
-                    responseUpdateError,
+                    responseFetchError,
             } = await client
-                .from("applicant_response")
-                .update(
-                    responseUpdate
+                .from(
+                    "applicant_response"
                 )
+                .select("id")
                 .eq(
-                    "id",
-                    existingResponse.id
-                );
+                    "applicantId",
+                    applicantId
+                )
+                .limit(1)
+                .maybeSingle();
 
             if (
-                responseUpdateError
+                responseFetchError
             ) {
                 console.error(
-                    "Error updating applicant response:",
-                    responseUpdateError
+                    "Error finding applicant response:",
+                    responseFetchError
                 );
 
                 return null;
             }
-        } else {
-            /*
-             * No response exists.
-             */
-            const {
-                error:
-                    responseInsertError,
-            } = await client
-                .from(
-                    "applicant_response"
-                )
-                .insert([
-                    {
-                        applicantId,
-                        branch:
-                            data.branch?.trim() ||
-                            "",
-                        responses:
-                            data.responses ||
-                            {},
-                    },
-                ]);
 
             if (
-                responseInsertError
+                existingResponse
             ) {
-                console.error(
-                    "Error creating applicant response:",
+                const responseUpdate: {
+                    branch?: string;
+                    responses?: Record<
+                        string,
+                        string
+                    >;
+                } = {};
+
+                if (
+                    data.branch !==
+                    undefined
+                ) {
+                    responseUpdate.branch =
+                        data.branch.trim();
+                }
+
+                if (
+                    data.responses !==
+                    undefined
+                ) {
+                    responseUpdate.responses =
+                        data.responses;
+                }
+
+                const {
+                    error:
+                        responseUpdateError,
+                } = await client
+                    .from(
+                        "applicant_response"
+                    )
+                    .update(
+                        responseUpdate
+                    )
+                    .eq(
+                        "id",
+                        existingResponse.id
+                    );
+
+                if (
+                    responseUpdateError
+                ) {
+                    console.error(
+                        "Error updating applicant response:",
+                        responseUpdateError
+                    );
+
+                    return null;
+                }
+            } else {
+                const {
+                    error:
+                        responseInsertError,
+                } = await client
+                    .from(
+                        "applicant_response"
+                    )
+                    .insert([
+                        {
+                            applicantId,
+
+                            branch:
+                                data.branch?.trim() ||
+                                "",
+
+                            responses:
+                                data.responses ||
+                                {},
+                        },
+                    ]);
+
+                if (
                     responseInsertError
-                );
-
-                return null;
+                ) {
+                    console.error(
+                        "Error creating applicant response:",
+                        responseInsertError
+                    );
+
+                    return null;
+                }
             }
         }
-    }
-
-    /*
-     * Return the final updated applicant.
-     */
-    return await fetchApplicantWithResponses(
-        applicantId
-    );
-};
+
+        /*
+         * Keep the shared interview schedule synchronized
+         * with admin/panelist edits as well.
+         *
+         * If this applicant is not PENDING, the scheduler will
+         * simply exclude them.
+         */
+        await requestInterviewSchedule();
+
+        return await fetchApplicantWithResponses(
+            applicantId
+        );
+    };
 
 /*
  * ---------------------------------------------------------
- * Accept or reject an applicant
+ * Accept / reject applicant
  * ---------------------------------------------------------
+ *
+ * PENDING -> ACCEPTED/REJECTED removes the applicant
+ * from the interview schedule.
  */
 
 export const updateApplicantDecision =
@@ -811,20 +1070,21 @@ export const updateApplicantDecision =
         remarks: string,
         reviewedBy: string
     ): Promise<boolean> => {
-        /*
-         * Use one timestamp for both Supabase
-         * and Google Sheets.
-         */
         const reviewedAt =
             new Date().toISOString();
 
-        const { error } = await client
+        const {
+            error,
+        } = await client
             .from("applicants")
             .update({
                 status:
                     status.toUpperCase(),
+
                 remarks,
+
                 reviewedBy,
+
                 reviewedAt,
             })
             .eq(
@@ -832,7 +1092,9 @@ export const updateApplicantDecision =
                 applicantId
             );
 
-        if (error) {
+        if (
+            error
+        ) {
             console.error(
                 "Error updating applicant decision:",
                 error
@@ -842,45 +1104,56 @@ export const updateApplicantDecision =
         }
 
         /*
-         * Sync decision to Results Sheet.
+         * Keep Results sheet synchronized.
          */
-        const {
-            data: sheetsData,
-            error: sheetsError,
-        } = await client.functions.invoke(
-            "sync-application-to-sheets",
-            {
-                body: {
-                    operation: "result",
-
-                    applicationId:
-                        applicantId,
-
-                    status,
-                    remarks,
-                    reviewedBy,
-                    reviewedAt,
-                },
-            }
-        );
 
-        /*
-         * Supabase remains the source of truth.
-         */
-        if (sheetsError) {
-            console.error(
-                "Decision saved to Supabase, but Results Sheet synchronization failed:",
+        try {
+            const {
+                error:
+                    sheetsError,
+            } =
+                await client.functions.invoke(
+                    "sync-application-to-sheets",
+                    {
+                        body: {
+                            operation:
+                                "result",
+
+                            applicationId:
+                                applicantId,
+
+                            status,
+
+                            remarks,
+
+                            reviewedBy,
+
+                            reviewedAt,
+                        },
+                    }
+                );
+
+            if (
                 sheetsError
-            );
-        } else if (
-            sheetsData?.success === false
-        ) {
+            ) {
+                console.error(
+                    "Decision saved to Supabase, but Results Sheet synchronization failed:",
+                    sheetsError
+                );
+            }
+        } catch (error) {
             console.error(
-                "Results Sheet synchronization failed:",
-                sheetsData
+                "Decision saved to Supabase, but Results Sheet synchronization failed:",
+                error
             );
         }
 
+        /*
+         * Remove the applicant from the shared interview
+         * schedule because they are no longer PENDING.
+         */
+        await requestInterviewSchedule();
+
         return true;
     };
 
@@ -888,18 +1161,27 @@ export const updateApplicantDecision =
  * ---------------------------------------------------------
  * Reset applicant decision
  * ---------------------------------------------------------
+ *
+ * PENDING again means the applicant needs an interview
+ * and therefore must re-enter the shared schedule.
  */
 
 export const resetApplicantDecision =
     async (
         applicantId: string
     ): Promise<boolean> => {
-        const { error } = await client
+        const {
+            error,
+        } = await client
             .from("applicants")
             .update({
-                status: "PENDING",
+                status:
+                    "PENDING",
+
                 remarks: null,
+
                 reviewedBy: null,
+
                 reviewedAt: null,
             })
             .eq(
@@ -907,7 +1189,9 @@ export const resetApplicantDecision =
                 applicantId
             );
 
-        if (error) {
+        if (
+            error
+        ) {
             console.error(
                 "Error resetting applicant decision:",
                 error
@@ -916,72 +1200,84 @@ export const resetApplicantDecision =
             return false;
         }
 
+        /*
+         * Re-add the applicant to the schedule.
+         */
+        await requestInterviewSchedule();
+
         return true;
     };
 
 /*
  * ---------------------------------------------------------
- * Subscribe to applicant changes in realtime
+ * Realtime applicant updates
  * ---------------------------------------------------------
  */
 
-export const subscribeToApplicantUpdates = (
-    onUpdate: (
-        applicant: ApplicantType
-    ) => void,
-    onInsert: (
-        applicant: ApplicantType
-    ) => void
-) => {
-    const channel = client
-        .channel(`applicants-status-${Date.now()}`)
-        .on(
-            "postgres_changes",
-            {
-                event: "UPDATE",
-                schema: "public",
-                table: "applicants",
-            },
-            (payload: any) => {
-                const item =
-                    payload.new as any;
+export const subscribeToApplicantUpdates =
+    (
+        onUpdate: (
+            applicant: ApplicantType
+        ) => void,
+
+        onInsert: (
+            applicant: ApplicantType
+        ) => void
+    ) => {
+        const channel =
+            client
+                .channel(
+                    `applicants-status-${Date.now()}`
+                )
+                .on(
+                    "postgres_changes",
+                    {
+                        event:
+                            "UPDATE",
 
-                onUpdate({
-                    ...item,
-                    status:
-                        item.status?.toLowerCase(),
-                    createdAt:
-                        item.createdAt ||
-                        item.created_at,
-                } as ApplicantType);
-            }
-        )
-        .on(
-            "postgres_changes",
-            {
-                event: "INSERT",
-                schema: "public",
-                table: "applicants",
-            },
-            (payload: any) => {
-                const item =
-                    payload.new as any;
+                        schema:
+                            "public",
 
-                onInsert({
-                    ...item,
-                    status:
-                        item.status?.toLowerCase(),
-                    createdAt:
-                        item.createdAt ||
-                        item.created_at,
-                } as ApplicantType);
-            }
-        )
-        .subscribe();
+                        table:
+                            "applicants",
+                    },
+                    (
+                        payload: any
+                    ) => {
+                        onUpdate(
+                            mapApplicant(
+                                payload.new
+                            )
+                        );
+                    }
+                )
+                .on(
+                    "postgres_changes",
+                    {
+                        event:
+                            "INSERT",
 
-    return () => {
-        client.removeChannel(
-            channel
-        );
-    };
-};
\ No newline at end of file
+                        schema:
+                            "public",
+
+                        table:
+                            "applicants",
+                    },
+                    (
+                        payload: any
+                    ) => {
+                        onInsert(
+                            mapApplicant(
+                                payload.new
+                            )
+                        );
+                    }
+                )
+                .subscribe();
+
+        return () => {
+            client.removeChannel(
+                channel
+            );
+        };
+    };
\ No newline at end of file
diff --git a/src/types/index.d.ts b/src/types/index.d.ts
index 275481d..1140d10 100644
--- a/src/types/index.d.ts
+++ b/src/types/index.d.ts
@@ -158,8 +158,11 @@ export interface ApplicantType {
     sid: string;
     phone?: string;
 
-    // Regular application fields
+    // Registration / scheduling fields
     branch?: string;
+    gender?: "male" | "female";
+    isHostellers?: boolean;
+
     responses?: Record<string, string>;
 
     isWalkin: boolean;
diff --git a/supabase/functions/schedule-interviews/deno.json b/supabase/functions/schedule-interviews/deno.json
new file mode 100644
index 0000000..45eb6d5
--- /dev/null
+++ b/supabase/functions/schedule-interviews/deno.json
@@ -0,0 +1,6 @@
+{
+  "tasks": {},
+  "imports": {
+    "@supabase/supabase-js": "npm:@supabase/supabase-js@2"
+  }
+}
\ No newline at end of file
diff --git a/supabase/functions/schedule-interviews/index.ts b/supabase/functions/schedule-interviews/index.ts
new file mode 100644
index 0000000..955c6c5
--- /dev/null
+++ b/supabase/functions/schedule-interviews/index.ts
@@ -0,0 +1,1017 @@
+import { createClient } from "npm:@supabase/supabase-js@2";
+
+const corsHeaders = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Headers":
+        "authorization, x-client-info, apikey, content-type",
+    "Access-Control-Allow-Methods":
+        "POST, OPTIONS",
+};
+
+const SLOT_MINUTES = 10;
+const FIRST_SLOT_MINUTES =
+    17 * 60 + 10; // 5:10 PM
+
+const SLOTS_PER_PANEL = 11;
+
+const INITIAL_DAY_1_PANELS = 10;
+const MAX_ONE_DAY_PANELS = 15;
+
+type ApplicantRow = {
+    id: string;
+    name: string;
+    sid: string;
+
+    gender?:
+        | "male"
+        | "female"
+        | null;
+
+    isHostellers?:
+        | boolean
+        | null;
+
+    applicant_response?:
+        | {
+              branch?:
+                  | string
+                  | null;
+          }
+        | {
+              branch?:
+                  | string
+                  | null;
+          }[]
+        | null;
+};
+
+type OrderedApplicant = {
+    applicant: ApplicantRow;
+    priority: number;
+};
+
+type ScheduleSlot = {
+    day:
+        | "Day 1"
+        | "Day 2";
+
+    time: string;
+
+    panel: number;
+};
+
+type PublicScheduleRow = {
+    day:
+        | "Day 1"
+        | "Day 2";
+
+    time: string;
+
+    panel: number;
+
+    name: string;
+
+    sid: string;
+};
+
+
+/*
+ * ---------------------------------------------------------
+ * Academic year
+ * ---------------------------------------------------------
+ */
+
+function getAcademicYear(): string {
+    const now = new Date();
+
+    const year =
+        now.getFullYear();
+
+    const month =
+        now.getMonth();
+
+    const startYear =
+        month >= 6
+            ? year
+            : year - 1;
+
+    return `${startYear}-${String(
+        startYear + 1
+    ).slice(-2)}`;
+}
+
+
+/*
+ * ---------------------------------------------------------
+ * Priority
+ * ---------------------------------------------------------
+ *
+ * 1. Female + Day Scholar
+ * 2. Male   + Day Scholar
+ * 3. Female + Hosteller
+ * 4. Male   + Hosteller
+ *
+ * Legacy/unspecified applicants get priority 5.
+ */
+
+function getPriority(
+    gender:
+        | "male"
+        | "female"
+        | null
+        | undefined,
+
+    isHostellers:
+        | boolean
+        | null
+        | undefined
+): number {
+    if (
+        gender === "female" &&
+        isHostellers === false
+    ) {
+        return 1;
+    }
+
+    if (
+        gender === "male" &&
+        isHostellers === false
+    ) {
+        return 2;
+    }
+
+    if (
+        gender === "female" &&
+        isHostellers === true
+    ) {
+        return 3;
+    }
+
+    if (
+        gender === "male" &&
+        isHostellers === true
+    ) {
+        return 4;
+    }
+
+    return 5;
+}
+
+
+/*
+ * ---------------------------------------------------------
+ * Randomize only within the same priority
+ * ---------------------------------------------------------
+ */
+
+function shuffle<T>(
+    items: T[]
+): T[] {
+    const result = [
+        ...items,
+    ];
+
+    for (
+        let i =
+            result.length - 1;
+        i > 0;
+        i--
+    ) {
+        const random =
+            new Uint32Array(1);
+
+        crypto.getRandomValues(
+            random
+        );
+
+        const j =
+            random[0] %
+            (i + 1);
+
+        [
+            result[i],
+            result[j],
+        ] = [
+            result[j],
+            result[i],
+        ];
+    }
+
+    return result;
+}
+
+function orderApplicants(
+    applicants: ApplicantRow[]
+): OrderedApplicant[] {
+    const groups =
+        new Map<
+            number,
+            ApplicantRow[]
+        >();
+
+    for (
+        const applicant of
+        applicants
+    ) {
+        const priority =
+            getPriority(
+                applicant.gender,
+                applicant.isHostellers
+            );
+
+        const group =
+            groups.get(
+                priority
+            ) ?? [];
+
+        group.push(
+            applicant
+        );
+
+        groups.set(
+            priority,
+            group
+        );
+    }
+
+    const result:
+        OrderedApplicant[] = [];
+
+    for (
+        const priority of [
+            1,
+            2,
+            3,
+            4,
+            5,
+        ]
+    ) {
+        const group =
+            groups.get(
+                priority
+            );
+
+        if (
+            !group ||
+            group.length === 0
+        ) {
+            continue;
+        }
+
+        for (
+            const applicant of
+            shuffle(group)
+        ) {
+            result.push({
+                applicant,
+                priority,
+            });
+        }
+    }
+
+    return result;
+}
+
+
+/*
+ * ---------------------------------------------------------
+ * Time formatting
+ * ---------------------------------------------------------
+ */
+
+function formatTime(
+    totalMinutes: number
+): string {
+    const hour24 =
+        Math.floor(
+            totalMinutes / 60
+        );
+
+    const minute =
+        totalMinutes % 60;
+
+    const suffix =
+        hour24 >= 12
+            ? "PM"
+            : "AM";
+
+    const hour12 =
+        hour24 % 12 || 12;
+
+    return `${hour12}:${String(
+        minute
+    ).padStart(
+        2,
+        "0"
+    )} ${suffix}`;
+}
+
+
+/*
+ * ---------------------------------------------------------
+ * Determine exact day/panel state
+ * ---------------------------------------------------------
+ *
+ * One-day rule:
+ *
+ * <=165 applicants
+ * → minimum panels needed
+ * → Day 1 only
+ *
+ * Two-day rule:
+ *
+ * Start:
+ *   10-0
+ *
+ * Then:
+ *   10-1
+ *   10-2
+ *   ...
+ *   10-10
+ *
+ * Then:
+ *   11-10
+ *   11-11
+ *   12-11
+ *   12-12
+ *   ...
+ *
+ * where:
+ *
+ *   first number = Day 1 panels
+ *   second number = Day 2 panels
+ */
+
+function determinePanelLayout(
+    applicantCount: number
+): {
+    days: 1 | 2;
+    day1Panels: number;
+    day2Panels: number;
+} {
+    if (
+        applicantCount <= 0
+    ) {
+        return {
+            days: 1,
+            day1Panels: 0,
+            day2Panels: 0,
+        };
+    }
+
+    /*
+     * First determine whether everything can fit
+     * into one day with at most 15 panels.
+     */
+    const requiredOneDayPanels =
+        Math.ceil(
+            applicantCount /
+                SLOTS_PER_PANEL
+        );
+
+    if (
+        requiredOneDayPanels <=
+        MAX_ONE_DAY_PANELS
+    ) {
+        return {
+            days: 1,
+            day1Panels:
+                requiredOneDayPanels,
+            day2Panels: 0,
+        };
+    }
+
+    /*
+     * Two-day mode.
+     *
+     * Start with 10 panels on Day 1
+     * and zero on Day 2.
+     */
+    let day1Panels =
+        INITIAL_DAY_1_PANELS;
+
+    let day2Panels = 0;
+
+    while (
+        day1Panels *
+                SLOTS_PER_PANEL +
+            day2Panels *
+                SLOTS_PER_PANEL <
+        applicantCount
+    ) {
+        /*
+         * First fill Day 2 until it reaches
+         * 10 panels.
+         */
+        if (
+            day2Panels <
+            INITIAL_DAY_1_PANELS
+        ) {
+            day2Panels += 1;
+
+            continue;
+        }
+
+        /*
+         * Once Day 2 reaches 10, increase
+         * Day 1 and Day 2 alternately:
+         *
+         * 11-10
+         * 11-11
+         * 12-11
+         * 12-12
+         * ...
+         */
+        if (
+            day1Panels ===
+            day2Panels
+        ) {
+            day1Panels += 1;
+        } else {
+            day2Panels += 1;
+        }
+    }
+
+    return {
+        days: 2,
+        day1Panels,
+        day2Panels,
+    };
+}
+
+
+/*
+ * ---------------------------------------------------------
+ * Generate chronological slot pool
+ * ---------------------------------------------------------
+ *
+ * Within each time:
+ *
+ * Day 1 panels first
+ * then Day 2 panels.
+ *
+ * This means that when we assign priority order,
+ * higher-priority applicants get the earliest actual
+ * available interview slots.
+ */
+
+function buildSlots(
+    days: 1 | 2,
+    day1Panels: number,
+    day2Panels: number
+): ScheduleSlot[] {
+    const slots:
+        ScheduleSlot[] = [];
+
+    for (
+        let slotIndex = 0;
+        slotIndex <
+        SLOTS_PER_PANEL;
+        slotIndex++
+    ) {
+        const start =
+            FIRST_SLOT_MINUTES +
+            slotIndex *
+                SLOT_MINUTES;
+
+        const time =
+            `${formatTime(
+                start
+            )} - ${formatTime(
+                start +
+                    SLOT_MINUTES
+            )}`;
+
+        /*
+         * Day 1.
+         */
+        for (
+            let panel = 1;
+            panel <= day1Panels;
+            panel++
+        ) {
+            slots.push({
+                day: "Day 1",
+                time,
+                panel,
+            });
+        }
+
+        /*
+         * Day 2.
+         */
+        if (
+            days === 2
+        ) {
+            for (
+                let panel = 1;
+                panel <= day2Panels;
+                panel++
+            ) {
+                slots.push({
+                    day: "Day 2",
+                    time,
+                    panel,
+                });
+            }
+        }
+    }
+
+    return slots;
+}
+
+
+/*
+ * ---------------------------------------------------------
+ * Build schedule
+ * ---------------------------------------------------------
+ */
+
+function buildSchedule(
+    applicants: ApplicantRow[]
+) {
+    const {
+        days,
+        day1Panels,
+        day2Panels,
+    } =
+        determinePanelLayout(
+            applicants.length
+        );
+
+    const orderedApplicants =
+        orderApplicants(
+            applicants
+        );
+
+    const slots =
+        buildSlots(
+            days,
+            day1Panels,
+            day2Panels
+        );
+
+    if (
+        orderedApplicants.length >
+        slots.length
+    ) {
+        throw new Error(
+            `Insufficient interview capacity for ${orderedApplicants.length} applicants`
+        );
+    }
+
+    const rows:
+        PublicScheduleRow[] = [];
+
+    /*
+     * Highest priority gets earliest available slot.
+     */
+    for (
+        let index = 0;
+        index <
+        orderedApplicants.length;
+        index++
+    ) {
+        const slot =
+            slots[index];
+
+        const {
+            applicant,
+        } =
+            orderedApplicants[
+                index
+            ];
+
+        rows.push({
+            day:
+                slot.day,
+
+            time:
+                slot.time,
+
+            panel:
+                slot.panel,
+
+            /*
+             * ONLY public information.
+             */
+            name:
+                applicant.name,
+
+            sid:
+                applicant.sid,
+        });
+    }
+
+    return {
+        academicYear:
+            getAcademicYear(),
+
+        days,
+
+        day1Panels,
+
+        day2Panels,
+
+        rows,
+    };
+}
+
+
+/*
+ * ---------------------------------------------------------
+ * Edge Function
+ * ---------------------------------------------------------
+ */
+
+Deno.serve(
+    async (
+        req: Request
+    ) => {
+        if (
+            req.method ===
+            "OPTIONS"
+        ) {
+            return new Response(
+                "ok",
+                {
+                    headers:
+                        corsHeaders,
+                }
+            );
+        }
+
+        if (
+            req.method !==
+            "POST"
+        ) {
+            return new Response(
+                JSON.stringify({
+                    success:
+                        false,
+                    error:
+                        "Method not allowed",
+                }),
+                {
+                    status: 405,
+                    headers: {
+                        ...corsHeaders,
+                        "Content-Type":
+                            "application/json",
+                    },
+                }
+            );
+        }
+
+        try {
+            /*
+             * -----------------------------------------------------
+             * Authenticate caller.
+             * -----------------------------------------------------
+             */
+
+            const authorization =
+                req.headers.get(
+                    "Authorization"
+                );
+
+            if (
+                !authorization
+            ) {
+                return new Response(
+                    JSON.stringify({
+                        success:
+                            false,
+                        error:
+                            "Authentication required",
+                    }),
+                    {
+                        status: 401,
+                        headers: {
+                            ...corsHeaders,
+                            "Content-Type":
+                                "application/json",
+                        },
+                    }
+                );
+            }
+
+            const supabaseUrl =
+                Deno.env.get(
+                    "SUPABASE_URL"
+                );
+
+            const supabaseAnonKey =
+                Deno.env.get(
+                    "SUPABASE_ANON_KEY"
+                );
+
+            const serviceRoleKey =
+                Deno.env.get(
+                    "SUPABASE_SERVICE_ROLE_KEY"
+                );
+
+            if (
+                !supabaseUrl ||
+                !supabaseAnonKey ||
+                !serviceRoleKey
+            ) {
+                throw new Error(
+                    "Supabase environment variables are missing"
+                );
+            }
+
+            const authenticatedClient =
+                createClient(
+                    supabaseUrl,
+                    supabaseAnonKey,
+                    {
+                        global: {
+                            headers: {
+                                Authorization:
+                                    authorization,
+                            },
+                        },
+                    }
+                );
+
+            const {
+                data: {
+                    user,
+                },
+                error:
+                    userError,
+            } =
+                await authenticatedClient
+                    .auth
+                    .getUser();
+
+            if (
+                userError ||
+                !user
+            ) {
+                return new Response(
+                    JSON.stringify({
+                        success:
+                            false,
+                        error:
+                            "Invalid or expired Supabase session",
+                    }),
+                    {
+                        status: 401,
+                        headers: {
+                            ...corsHeaders,
+                            "Content-Type":
+                                "application/json",
+                        },
+                    }
+                );
+            }
+
+            /*
+             * Service-role client is only used inside
+             * this trusted Edge Function.
+             */
+            const adminClient =
+                createClient(
+                    supabaseUrl,
+                    serviceRoleKey
+                );
+
+            /*
+             * -----------------------------------------------------
+             * Google configuration.
+             * -----------------------------------------------------
+             */
+
+            const googleScriptUrl =
+                Deno.env.get(
+                    "GOOGLE_SHEETS_SCRIPT_URL"
+                );
+
+            const googleSheetsSecret =
+                Deno.env.get(
+                    "GOOGLE_SHEETS_SECRET"
+                );
+
+            if (
+                !googleScriptUrl ||
+                !googleSheetsSecret
+            ) {
+                throw new Error(
+                    "Google Sheets configuration is missing"
+                );
+            }
+
+            /*
+             * -----------------------------------------------------
+             * Fetch current PENDING applicants.
+             * -----------------------------------------------------
+             *
+             * PENDING means the applicant still needs
+             * an interview.
+             *
+             * ACCEPTED/REJECTED are deliberately excluded.
+             *
+             * Walk-ins are excluded.
+             */
+
+            const {
+                data: applicants,
+                error:
+                    applicantsError,
+            } =
+                await adminClient
+                    .from(
+                        "applicants"
+                    )
+                    .select(
+                        "id, name, sid, gender, isHostellers, applicant_response(branch)"
+                    )
+                    .eq(
+                        "status",
+                        "PENDING"
+                    )
+                    .eq(
+                        "isWalkin",
+                        false
+                    )
+                    .order(
+                        "created_at",
+                        {
+                            ascending:
+                                true,
+                        }
+                    );
+
+            if (
+                applicantsError
+            ) {
+                throw new Error(
+                    `Failed to fetch pending applicants: ${applicantsError.message}`
+                );
+            }
+
+            /*
+             * -----------------------------------------------------
+             * Calculate complete schedule.
+             * -----------------------------------------------------
+             */
+
+            const schedule =
+                buildSchedule(
+                    (
+                        applicants ??
+                        []
+                    ) as ApplicantRow[]
+                );
+
+            /*
+             * -----------------------------------------------------
+             * Send ONLY:
+             *
+             * Day
+             * Time
+             * Panel
+             * Name
+             * SID
+             *
+             * to the shared Google Sheet.
+             * -----------------------------------------------------
+             */
+
+            const generatedAt =
+                Date.now();
+
+            const googleResponse =
+                await fetch(
+                    googleScriptUrl,
+                    {
+                        method:
+                            "POST",
+
+                        headers: {
+                            "Content-Type":
+                                "application/json",
+                        },
+
+                        body:
+                            JSON.stringify({
+                                operation:
+                                    "schedule",
+
+                                academicYear:
+                                    schedule.academicYear,
+
+                                days:
+                                    schedule.days,
+
+                                day1Panels:
+                                    schedule.day1Panels,
+
+                                day2Panels:
+                                    schedule.day2Panels,
+
+                                generatedAt,
+
+                                generatedBy:
+                                    user.id,
+
+                                rows:
+                                    schedule.rows,
+
+                                secret:
+                                    googleSheetsSecret,
+                            }),
+                    }
+                );
+
+            let googleResult:
+                {
+                    success?: boolean;
+                    stale?: boolean;
+                    error?: string;
+                };
+
+            try {
+                googleResult =
+                    await googleResponse.json();
+            } catch {
+                throw new Error(
+                    `Google Apps Script returned an invalid response (HTTP ${googleResponse.status})`
+                );
+            }
+
+            if (
+                !googleResponse.ok ||
+                !googleResult.success
+            ) {
+                throw new Error(
+                    googleResult.error ||
+                        `Interview schedule synchronization failed (HTTP ${googleResponse.status})`
+                );
+            }
+
+            return new Response(
+                JSON.stringify({
+                    success:
+                        true,
+
+                    academicYear:
+                        schedule.academicYear,
+
+                    days:
+                        schedule.days,
+
+                    day1Panels:
+                        schedule.day1Panels,
+
+                    day2Panels:
+                        schedule.day2Panels,
+
+                    applicantCount:
+                        applicants?.length ??
+                        0,
+
+                    stale:
+                        googleResult.stale ??
+                        false,
+                }),
+                {
+                    status: 200,
+                    headers: {
+                        ...corsHeaders,
+                        "Content-Type":
+                            "application/json",
+                    },
+                }
+            );
+        } catch (error) {
+            console.error(
+                "schedule-interviews error:",
+                error
+            );
+
+            return new Response(
+                JSON.stringify({
+                    success:
+                        false,
+
+                    error:
+                        error instanceof
+                        Error
+                            ? error.message
+                            : "Unknown error",
+                }),
+                {
+                    status: 500,
+                    headers: {
+                        ...corsHeaders,
+                        "Content-Type":
+                            "application/json",
+                    },
+                }
+            );
+        }
+    }
+);
\ No newline at end of file