From c531aeb663f51dc51f5e8704e1ee6a0854577833 Mon Sep 17 00:00:00 2001
From: DhairyaSood <dhairyasood20042006@gmail.com>
Date: Sat, 15 Aug 2026 14:04:56 +0530
Subject: [PATCH] feat: improve registration and application editing

---
 src/components/ApplicationForm.tsx            | 912 ++++++++++++++++--
 .../supabase/actions/applicants.actions.ts    | 566 ++++++++---
 src/types/index.d.ts                          |   2 +
 .../sync-application-to-sheets/index.ts       | 388 ++++++--
 4 files changed, 1521 insertions(+), 347 deletions(-)

diff --git a/src/components/ApplicationForm.tsx b/src/components/ApplicationForm.tsx
index 19cfd69..046c94b 100644
--- a/src/components/ApplicationForm.tsx
+++ b/src/components/ApplicationForm.tsx
@@ -1,5 +1,15 @@
-import { useState } from "react";
-import { createApplicant } from "@/lib/supabase/actions/applicants.actions";
+import {
+    useEffect,
+    useState,
+} from "react";
+
+import {
+    createApplicant,
+    fetchMyApplication,
+    updateApplicantPersonalInfo,
+} from "@/lib/supabase/actions/applicants.actions";
+
+import type { ApplicantType } from "@/types";
 
 const branches = [
     "Aerospace Engineering",
@@ -37,21 +47,54 @@ export const APPLICATION_QUESTIONS = [
     },
 ];
 
+const createEmptyResponses = () =>
+    APPLICATION_QUESTIONS.reduce(
+        (acc, question) => {
+            acc[question.id] = "";
+            return acc;
+        },
+        {} as Record<string, string>
+    );
+
 const initialForm = {
     name: "",
+    phone: "",
     sid: "",
     branch: "",
-    responses: APPLICATION_QUESTIONS.reduce((acc, q) => {
-        acc[q.id] = "";
-        return acc;
-    }, {} as Record<string, string>),
+    responses:
+        createEmptyResponses(),
 };
 
 export default function ApplicationForm() {
-    const [form, setForm] = useState(initialForm);
-    const [error, setError] = useState("");
-    const [success, setSuccess] = useState(false);
-    const [submitting, setSubmitting] = useState(false);
+    const [form, setForm] =
+        useState(initialForm);
+
+    const [application, setApplication] =
+        useState<ApplicantType | null>(
+            null
+        );
+
+    const [
+        checkingApplication,
+        setCheckingApplication,
+    ] = useState(true);
+
+    const [error, setError] =
+        useState("");
+
+    const [submitting, setSubmitting] =
+        useState(false);
+
+    const [
+        savingPersonalInfo,
+        setSavingPersonalInfo,
+    ] = useState(false);
+
+    /*
+     * ---------------------------------------------------------
+     * Field helpers
+     * ---------------------------------------------------------
+     */
 
     const updateField = (
         field: keyof typeof initialForm,
@@ -63,7 +106,10 @@ export default function ApplicationForm() {
         }));
     };
 
-    const updateResponse = (questionId: string, value: string) => {
+    const updateResponse = (
+        questionId: string,
+        value: string
+    ) => {
         setForm((current) => ({
             ...current,
             responses: {
@@ -73,58 +119,173 @@ export default function ApplicationForm() {
         }));
     };
 
+    /*
+     * ---------------------------------------------------------
+     * Load existing application
+     * ---------------------------------------------------------
+     */
+
+    useEffect(() => {
+        let active = true;
+
+        const loadApplication =
+            async () => {
+                const existing =
+                    await fetchMyApplication();
+
+                if (!active) {
+                    return;
+                }
+
+                if (existing) {
+                    setApplication(
+                        existing
+                    );
+
+                    setForm({
+                        name:
+                            existing.name ||
+                            "",
+                        phone:
+                            existing.phone ||
+                            "",
+                        sid:
+                            existing.sid ||
+                            "",
+                        branch:
+                            existing.branch ||
+                            "",
+                        responses:
+                            existing.responses ||
+                            createEmptyResponses(),
+                    });
+                }
+
+                setCheckingApplication(
+                    false
+                );
+            };
+
+        void loadApplication();
+
+        return () => {
+            active = false;
+        };
+    }, []);
+
+    /*
+     * ---------------------------------------------------------
+     * Create new application
+     * ---------------------------------------------------------
+     */
+
     const handleSubmit = async (
         event: React.FormEvent<HTMLFormElement>
     ) => {
         event.preventDefault();
 
         setError("");
-        setSuccess(false);
-
-        const name = form.name.trim();
-        const sid = form.sid.trim();
-        const branch = form.branch;
-        
-        // Ensure all required fields and questions are filled
-        if (!name || !sid || !branch) {
-            setError("Please fill in all the required personal fields.");
+
+        const name =
+            form.name.trim();
+
+        const phone =
+            form.phone.trim();
+
+        const sid =
+            form.sid.trim();
+
+        const branch =
+            form.branch;
+
+        if (
+            !name ||
+            !phone ||
+            !sid ||
+            !branch
+        ) {
+            setError(
+                "Please fill in all the required personal fields."
+            );
+
             return;
         }
 
-        const missingResponses = APPLICATION_QUESTIONS.some(
-            (q) => !form.responses[q.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;
         }
 
-        if (!/^\d{8}$/.test(sid)) {
-            setError("SID must be exactly 8 digits.");
+        if (
+            !/^\d{8}$/.test(sid)
+        ) {
+            setError(
+                "SID must be exactly 8 digits."
+            );
+
+            return;
+        }
+
+        const missingResponses =
+            APPLICATION_QUESTIONS.some(
+                (question) =>
+                    !form.responses[
+                        question.id
+                    ].trim()
+            );
+
+        if (missingResponses) {
+            setError(
+                "Please answer all the application questions."
+            );
+
             return;
         }
 
+        const trimmedResponses =
+            Object.keys(
+                form.responses
+            ).reduce(
+                (acc, key) => {
+                    acc[key] =
+                        form.responses[
+                            key
+                        ].trim();
+
+                    return acc;
+                },
+                {} as Record<
+                    string,
+                    string
+                >
+            );
+
         setSubmitting(true);
 
         try {
-            // Trim responses
-            const trimmedResponses = Object.keys(form.responses).reduce((acc, key) => {
-                acc[key] = form.responses[key].trim();
-                return acc;
-            }, {} as Record<string, string>);
-
-            const result = await createApplicant(
-                name,
-                sid,
-                branch,
-                trimmedResponses
-            );
+            const result =
+                await createApplicant(
+                    name,
+                    sid,
+                    phone,
+                    branch,
+                    trimmedResponses
+                );
 
             if (!result.success) {
-                if (result.reason === "duplicate") {
+                if (
+                    result.reason ===
+                    "duplicate"
+                ) {
                     setError(
-                        "An application with this SID has already been submitted."
+                        "You have already submitted an application."
                     );
                 } else {
                     setError(
@@ -135,10 +296,33 @@ export default function ApplicationForm() {
                 return;
             }
 
-            setSuccess(true);
-            setForm(initialForm);
-        } catch (error) {
-            console.error("Unexpected application submission error:", error);
+            setApplication(
+                result.applicant
+            );
+
+            setForm({
+                name:
+                    result.applicant.name ||
+                    "",
+                phone:
+                    result.applicant.phone ||
+                    "",
+                sid:
+                    result.applicant.sid ||
+                    "",
+                branch:
+                    result.applicant.branch ||
+                    "",
+                responses:
+                    result.applicant
+                        .responses ||
+                    createEmptyResponses(),
+            });
+        } catch (submissionError) {
+            console.error(
+                "Unexpected application submission error:",
+                submissionError
+            );
 
             setError(
                 "We could not submit your application. Please try again."
@@ -148,30 +332,443 @@ export default function ApplicationForm() {
         }
     };
 
-    if (success) {
+    /*
+     * ---------------------------------------------------------
+     * Save personal information
+     * ---------------------------------------------------------
+     */
+
+    const handleSavePersonalInfo =
+        async () => {
+            if (!application) {
+                return;
+            }
+
+            setError("");
+
+            const name =
+                form.name.trim();
+
+            const phone =
+                form.phone.trim();
+
+            const sid =
+                form.sid.trim();
+
+            const branch =
+                form.branch;
+
+            if (
+                !name ||
+                !phone ||
+                !sid ||
+                !branch
+            ) {
+                setError(
+                    "Please fill in all the personal information."
+                );
+
+                return;
+            }
+
+            if (
+                !/^[6-9]\d{9}$/.test(
+                    phone
+                )
+            ) {
+                setError(
+                    "Please enter a valid 10-digit phone number."
+                );
+
+                return;
+            }
+
+            if (
+                !/^\d{8}$/.test(sid)
+            ) {
+                setError(
+                    "SID must be exactly 8 digits."
+                );
+
+                return;
+            }
+
+            setSavingPersonalInfo(
+                true
+            );
+
+            try {
+                const result =
+                    await updateApplicantPersonalInfo(
+                        application.id,
+                        name,
+                        phone,
+                        sid,
+                        branch
+                    );
+
+                if (!result.success) {
+                    setError(
+                        result.reason ===
+                            "not_found"
+                            ? "Your application could not be found or can no longer be edited."
+                            : "Could not update your personal information. Please try again."
+                    );
+
+                    return;
+                }
+
+                setApplication(
+                    result.applicant
+                );
+
+                setForm(
+                    (current) => ({
+                        ...current,
+                        name:
+                            result.applicant
+                                .name,
+                        phone:
+                            result.applicant
+                                .phone ||
+                            "",
+                        sid:
+                            result.applicant
+                                .sid,
+                        branch:
+                            result.applicant
+                                .branch ||
+                            "",
+                    })
+                );
+            } catch (updateError) {
+                console.error(
+                    "Error updating personal information:",
+                    updateError
+                );
+
+                setError(
+                    "Could not update your personal information. Please try again."
+                );
+            } finally {
+                setSavingPersonalInfo(
+                    false
+                );
+            }
+        };
+
+    /*
+     * ---------------------------------------------------------
+     * Loading state
+     * ---------------------------------------------------------
+     */
+
+    if (checkingApplication) {
         return (
             <div className="mx-auto max-w-3xl rounded-xl border bg-white p-8 text-center shadow-sm">
-                <div className="mx-auto mb-4 flex h-12 w-12 items-center justify-center rounded-full bg-green-100 text-green-700">
-                    ✓
+                <p className="text-sm text-muted-foreground">
+                    Checking your application...
+                </p>
+            </div>
+        );
+    }
+
+    /*
+     * ---------------------------------------------------------
+     * Existing application
+     * ---------------------------------------------------------
+     */
+
+    if (application) {
+        const canEdit =
+            application.status ===
+            "pending";
+
+        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>
+                            <h2 className="text-xl font-semibold">
+                                Personal Information
+                            </h2>
+
+                            <p className="mt-1 text-sm text-muted-foreground">
+                                {canEdit
+                                    ? "You can update your personal information while your application is pending."
+                                    : "Your personal information is locked because your application has been reviewed."}
+                            </p>
+                        </div>
+
+                        <span
+                            className={`rounded-full px-3 py-1 text-xs font-medium ${
+                                application.status ===
+                                "accepted"
+                                    ? "bg-green-100 text-green-700"
+                                    : application.status ===
+                                        "rejected"
+                                      ? "bg-red-100 text-red-700"
+                                      : "bg-yellow-100 text-yellow-700"
+                            }`}
+                        >
+                            {application.status
+                                .charAt(
+                                    0
+                                )
+                                .toUpperCase() +
+                                application.status.slice(
+                                    1
+                                )}
+                        </span>
+                    </div>
+
+                    <div className="mt-6 space-y-6">
+                        {/* Name + Phone */}
+                        <div className="grid gap-6 md:grid-cols-2">
+                            <div className="space-y-2">
+                                <label
+                                    htmlFor="existing-name"
+                                    className="text-sm font-medium"
+                                >
+                                    Name
+                                </label>
+
+                                <input
+                                    id="existing-name"
+                                    type="text"
+                                    value={
+                                        form.name
+                                    }
+                                    disabled={
+                                        !canEdit
+                                    }
+                                    onChange={(
+                                        event
+                                    ) =>
+                                        updateField(
+                                            "name",
+                                            event
+                                                .target
+                                                .value
+                                        )
+                                    }
+                                    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"
+                                />
+                            </div>
+
+                            <div className="space-y-2">
+                                <label
+                                    htmlFor="existing-phone"
+                                    className="text-sm font-medium"
+                                >
+                                    Phone Number
+                                </label>
+
+                                <input
+                                    id="existing-phone"
+                                    type="tel"
+                                    inputMode="numeric"
+                                    maxLength={
+                                        10
+                                    }
+                                    value={
+                                        form.phone
+                                    }
+                                    disabled={
+                                        !canEdit
+                                    }
+                                    onChange={(
+                                        event
+                                    ) =>
+                                        updateField(
+                                            "phone",
+                                            event.target.value.replace(
+                                                /\D/g,
+                                                ""
+                                            )
+                                        )
+                                    }
+                                    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"
+                                />
+                            </div>
+                        </div>
+
+                        {/* SID + Branch */}
+                        <div className="grid gap-6 md:grid-cols-2">
+                            <div className="space-y-2">
+                                <label
+                                    htmlFor="existing-sid"
+                                    className="text-sm font-medium"
+                                >
+                                    SID
+                                </label>
+
+                                <input
+                                    id="existing-sid"
+                                    type="text"
+                                    inputMode="numeric"
+                                    maxLength={
+                                        8
+                                    }
+                                    value={
+                                        form.sid
+                                    }
+                                    disabled={
+                                        !canEdit
+                                    }
+                                    onChange={(
+                                        event
+                                    ) =>
+                                        updateField(
+                                            "sid",
+                                            event.target.value.replace(
+                                                /\D/g,
+                                                ""
+                                            )
+                                        )
+                                    }
+                                    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"
+                                />
+                            </div>
+
+                            <div className="space-y-2">
+                                <label
+                                    htmlFor="existing-branch"
+                                    className="text-sm font-medium"
+                                >
+                                    Branch
+                                </label>
+
+                                <select
+                                    id="existing-branch"
+                                    value={
+                                        form.branch
+                                    }
+                                    disabled={
+                                        !canEdit
+                                    }
+                                    onChange={(
+                                        event
+                                    ) =>
+                                        updateField(
+                                            "branch",
+                                            event
+                                                .target
+                                                .value
+                                        )
+                                    }
+                                    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 branch
+                                    </option>
+
+                                    {branches.map(
+                                        (
+                                            branch
+                                        ) => (
+                                            <option
+                                                key={
+                                                    branch
+                                                }
+                                                value={
+                                                    branch
+                                                }
+                                            >
+                                                {
+                                                    branch
+                                                }
+                                            </option>
+                                        )
+                                    )}
+                                </select>
+                            </div>
+                        </div>
+
+                        {canEdit && (
+                            <button
+                                type="button"
+                                onClick={
+                                    handleSavePersonalInfo
+                                }
+                                disabled={
+                                    savingPersonalInfo
+                                }
+                                className="rounded-md bg-primary px-5 py-2.5 text-sm font-medium text-primary-foreground transition-opacity hover:opacity-90 disabled:cursor-not-allowed disabled:opacity-50"
+                            >
+                                {savingPersonalInfo
+                                    ? "Saving..."
+                                    : "Save Personal Information"}
+                            </button>
+                        )}
+                    </div>
                 </div>
 
-                <h2 className="text-2xl font-semibold">
-                    Application Submitted
-                </h2>
+                {/* Read-only answers */}
+                <div className="rounded-xl border bg-white p-6 shadow-sm">
+                    <h2 className="text-xl font-semibold">
+                        Submitted Application
+                    </h2>
 
-                <p className="mt-3 text-muted-foreground">
-                    Your application has been successfully submitted
-                    to the Robotics Society.
-                </p>
+                    <p className="mt-1 text-sm text-muted-foreground">
+                        Your submitted answers
+                        cannot be changed.
+                    </p>
 
-                <p className="mt-2 text-sm text-muted-foreground">
-                    Please wait for further communication regarding
-                    the selection process.
-                </p>
+                    <div className="mt-6 space-y-7">
+                        {APPLICATION_QUESTIONS.map(
+                            (
+                                question
+                            ) => (
+                                <div
+                                    key={
+                                        question.id
+                                    }
+                                    className="space-y-3"
+                                >
+                                    <p className="text-sm font-medium leading-6">
+                                        <span className="mr-2 text-muted-foreground">
+                                            {
+                                                question.id
+                                            }.
+                                        </span>
+
+                                        {
+                                            question.text
+                                        }
+                                    </p>
+
+                                    <div className="rounded-md border bg-gray-50 p-4">
+                                        <p className="whitespace-pre-wrap text-sm leading-6 text-gray-700">
+                                            {application
+                                                .responses?.[
+                                                question.id
+                                            ] ||
+                                                "No answer provided."}
+                                        </p>
+                                    </div>
+                                </div>
+                            )
+                        )}
+                    </div>
+                </div>
+
+                {error && (
+                    <div className="rounded-md border border-red-200 bg-red-50 p-4 text-sm text-red-700">
+                        {error}
+                    </div>
+                )}
             </div>
         );
     }
 
+    /*
+     * ---------------------------------------------------------
+     * New application form
+     * ---------------------------------------------------------
+     */
+
     return (
         <form
             onSubmit={handleSubmit}
@@ -188,25 +785,70 @@ export default function ApplicationForm() {
                 </p>
 
                 <div className="mt-6 space-y-6">
-                    {/* Name */}
-                    <div className="space-y-2">
-                        <label
-                            htmlFor="name"
-                            className="text-sm font-medium"
-                        >
-                            Name
-                        </label>
-
-                        <input
-                            id="name"
-                            type="text"
-                            value={form.name}
-                            onChange={(e) =>
-                                updateField("name", e.target.value)
-                            }
-                            placeholder="Enter your full name"
-                            className="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm outline-none placeholder:text-muted-foreground focus-visible:ring-2 focus-visible:ring-ring"
-                        />
+                    {/* Name + Phone */}
+                    <div className="grid gap-6 md:grid-cols-2">
+                        <div className="space-y-2">
+                            <label
+                                htmlFor="name"
+                                className="text-sm font-medium"
+                            >
+                                Name
+                            </label>
+
+                            <input
+                                id="name"
+                                type="text"
+                                value={
+                                    form.name
+                                }
+                                onChange={(
+                                    event
+                                ) =>
+                                    updateField(
+                                        "name",
+                                        event
+                                            .target
+                                            .value
+                                    )
+                                }
+                                placeholder="Enter your full name"
+                                className="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm outline-none"
+                            />
+                        </div>
+
+                        <div className="space-y-2">
+                            <label
+                                htmlFor="phone"
+                                className="text-sm font-medium"
+                            >
+                                Phone Number
+                            </label>
+
+                            <input
+                                id="phone"
+                                type="tel"
+                                inputMode="numeric"
+                                maxLength={
+                                    10
+                                }
+                                value={
+                                    form.phone
+                                }
+                                onChange={(
+                                    event
+                                ) =>
+                                    updateField(
+                                        "phone",
+                                        event.target.value.replace(
+                                            /\D/g,
+                                            ""
+                                        )
+                                    )
+                                }
+                                placeholder="10-digit phone number"
+                                className="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm outline-none"
+                            />
+                        </div>
                     </div>
 
                     {/* SID + Branch */}
@@ -223,16 +865,25 @@ export default function ApplicationForm() {
                                 id="sid"
                                 type="text"
                                 inputMode="numeric"
-                                maxLength={8}
-                                value={form.sid}
-                                onChange={(e) =>
+                                maxLength={
+                                    8
+                                }
+                                value={
+                                    form.sid
+                                }
+                                onChange={(
+                                    event
+                                ) =>
                                     updateField(
                                         "sid",
-                                        e.target.value.replace(/\D/g, "")
+                                        event.target.value.replace(
+                                            /\D/g,
+                                            ""
+                                        )
                                     )
                                 }
                                 placeholder="8-digit SID"
-                                className="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm outline-none placeholder:text-muted-foreground focus-visible:ring-2 focus-visible:ring-ring"
+                                className="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm outline-none"
                             />
                         </div>
 
@@ -246,24 +897,43 @@ export default function ApplicationForm() {
 
                             <select
                                 id="branch"
-                                value={form.branch}
-                                onChange={(e) =>
-                                    updateField("branch", e.target.value)
+                                value={
+                                    form.branch
+                                }
+                                onChange={(
+                                    event
+                                ) =>
+                                    updateField(
+                                        "branch",
+                                        event
+                                            .target
+                                            .value
+                                    )
                                 }
-                                className="flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm outline-none focus-visible:ring-2 focus-visible:ring-ring"
+                                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 branch
                                 </option>
 
-                                {branches.map((branch) => (
-                                    <option
-                                        key={branch}
-                                        value={branch}
-                                    >
-                                        {branch}
-                                    </option>
-                                ))}
+                                {branches.map(
+                                    (
+                                        branch
+                                    ) => (
+                                        <option
+                                            key={
+                                                branch
+                                            }
+                                            value={
+                                                branch
+                                            }
+                                        >
+                                            {
+                                                branch
+                                            }
+                                        </option>
+                                    )
+                                )}
                             </select>
                         </div>
                     </div>
@@ -277,15 +947,37 @@ export default function ApplicationForm() {
                 </h2>
 
                 <div className="mt-6 space-y-7">
-                    {APPLICATION_QUESTIONS.map((q) => (
-                        <Question
-                            key={q.id}
-                            number={q.id}
-                            question={q.text}
-                            value={form.responses[q.id]}
-                            onChange={(value) => updateResponse(q.id, value)}
-                        />
-                    ))}
+                    {APPLICATION_QUESTIONS.map(
+                        (
+                            question
+                        ) => (
+                            <Question
+                                key={
+                                    question.id
+                                }
+                                number={
+                                    question.id
+                                }
+                                question={
+                                    question.text
+                                }
+                                value={
+                                    form
+                                        .responses[
+                                        question.id
+                                    ]
+                                }
+                                onChange={(
+                                    value
+                                ) =>
+                                    updateResponse(
+                                        question.id,
+                                        value
+                                    )
+                                }
+                            />
+                        )
+                    )}
                 </div>
             </div>
 
@@ -312,7 +1004,9 @@ interface QuestionProps {
     number: string;
     question: string;
     value: string;
-    onChange: (value: string) => void;
+    onChange: (
+        value: string
+    ) => void;
 }
 
 function Question({
@@ -337,10 +1031,14 @@ function Question({
             <textarea
                 id={number}
                 value={value}
-                onChange={(e) => onChange(e.target.value)}
+                onChange={(event) =>
+                    onChange(
+                        event.target.value
+                    )
+                }
                 rows={5}
                 placeholder="Write your answer here..."
-                className="flex min-h-[120px] w-full rounded-md border border-input bg-background px-3 py-2 text-sm outline-none placeholder:text-muted-foreground focus-visible:ring-2 focus-visible:ring-ring"
+                className="flex min-h-[120px] w-full rounded-md border border-input bg-background px-3 py-2 text-sm outline-none"
             />
         </div>
     );
diff --git a/src/lib/supabase/actions/applicants.actions.ts b/src/lib/supabase/actions/applicants.actions.ts
index 6af5306..892349e 100644
--- a/src/lib/supabase/actions/applicants.actions.ts
+++ b/src/lib/supabase/actions/applicants.actions.ts
@@ -11,10 +11,33 @@ export type CreateApplicantResult =
           reason: "duplicate" | "error";
       };
 
-export const fetchApplicants = async (): Promise<ApplicantType[]> => {
+const mapApplicant = (item: any): ApplicantType => {
+    const response = item.applicant_response;
+
+    const responseData = Array.isArray(response)
+        ? response[0]
+        : response;
+
+    return {
+        ...item,
+        userId: item.userId,
+        status: item.status?.toLowerCase(),
+        createdAt:
+            item.createdAt ||
+            item.created_at,
+        branch: responseData?.branch,
+        responses: responseData?.responses,
+    } as ApplicantType;
+};
+
+export const fetchApplicants = async (): Promise<
+    ApplicantType[]
+> => {
     const { data, error } = await client
         .from("applicants")
-        .select("*, applicant_response(branch, responses)")
+        .select(
+            "*, applicant_response(branch, responses)"
+        )
         .order("created_at", {
             ascending: false,
         });
@@ -28,23 +51,7 @@ export const fetchApplicants = async (): Promise<ApplicantType[]> => {
         return [];
     }
 
-    return (data as any[]).map((item) => {
-        const response = item.applicant_response;
-
-        const responseData = Array.isArray(response)
-            ? response[0]
-            : response;
-
-        return {
-            ...item,
-            status: item.status?.toLowerCase(),
-            createdAt:
-                item.createdAt ||
-                item.created_at,
-            branch: responseData?.branch,
-            responses: responseData?.responses,
-        };
-    }) as ApplicantType[];
+    return (data as any[]).map(mapApplicant);
 };
 
 export const fetchApplicantWithResponses = async (
@@ -67,29 +74,60 @@ export const fetchApplicantWithResponses = async (
         return null;
     }
 
-    const response =
-        (data as any).applicant_response;
+    return mapApplicant(data);
+};
 
-    const responseData = Array.isArray(response)
-        ? response[0]
-        : response;
+/*
+ * ---------------------------------------------------------
+ * Fetch the currently logged-in user's application.
+ * ---------------------------------------------------------
+ */
+
+export const fetchMyApplication =
+    async (): Promise<ApplicantType | null> => {
+        const {
+            data: { user },
+            error: userError,
+        } = await client.auth.getUser();
+
+        if (userError || !user) {
+            return null;
+        }
 
-    return {
-        ...data,
-        status: data.status?.toLowerCase(),
-        createdAt:
-            data.createdAt ||
-            data.created_at,
-        branch: responseData?.branch,
-        responses: responseData?.responses,
-    } as ApplicantType;
-};
+        const { data, error } = await client
+            .from("applicants")
+            .select(
+                "*, applicant_response(branch, responses)"
+            )
+            .eq("userId", user.id)
+            .maybeSingle();
+
+        if (error) {
+            console.error(
+                "Error fetching current user's application:",
+                error
+            );
+
+            return null;
+        }
+
+        if (!data) {
+            return null;
+        }
+
+        return mapApplicant(data);
+    };
 
 export const createWalkIn = async (
     name: string,
     sid: string,
     phone: string
 ): Promise<ApplicantType | null> => {
+    /*
+     * Walk-ins are still created exactly as before.
+     * They are not tied to a user account.
+     */
+
     const { data, error } = await client
         .from("applicants")
         .insert([
@@ -115,7 +153,8 @@ export const createWalkIn = async (
 
     return {
         ...data,
-        status: data.status?.toLowerCase(),
+        status:
+            data.status?.toLowerCase(),
         createdAt:
             data.createdAt ||
             data.created_at,
@@ -125,12 +164,75 @@ export const createWalkIn = async (
 export const createApplicant = async (
     name: string,
     sid: string,
+    phone: string,
     branch: string,
     responses: Record<string, string>
 ): Promise<CreateApplicantResult> => {
     /*
      * ---------------------------------------------------------
-     * 1. Create applicant in Supabase
+     * 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
+        );
+
+        return {
+            success: false,
+            reason: "error",
+        };
+    }
+
+    /*
+     * ---------------------------------------------------------
+     * 2. Friendly existing-application check
+     * ---------------------------------------------------------
+     *
+     * The UNIQUE constraint on userId in Supabase is the
+     * actual protection against duplicate applications.
+     *
+     * This query is only for giving a clean UI response.
+     */
+
+    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
+        );
+
+        return {
+            success: false,
+            reason: "error",
+        };
+    }
+
+    if (existingApplicant) {
+        return {
+            success: false,
+            reason: "duplicate",
+        };
+    }
+
+    /*
+     * ---------------------------------------------------------
+     * 3. Create applicant
      * ---------------------------------------------------------
      */
 
@@ -141,8 +243,10 @@ export const createApplicant = async (
         .from("applicants")
         .insert([
             {
+                userId: user.id,
                 name,
                 sid,
+                phone: phone || null,
                 isWalkin: false,
                 status: "PENDING",
             },
@@ -151,6 +255,11 @@ export const createApplicant = async (
         .single();
 
     if (applicantError) {
+        /*
+         * PostgreSQL unique constraint violation.
+         * This is the definitive one-account-one-application
+         * protection.
+         */
         if (applicantError.code === "23505") {
             console.error(
                 "Duplicate application:",
@@ -169,10 +278,14 @@ export const createApplicant = async (
         );
 
         console.error("Error details:", {
-            message: applicantError.message,
-            details: applicantError.details,
-            hint: applicantError.hint,
-            code: applicantError.code,
+            message:
+                applicantError.message,
+            details:
+                applicantError.details,
+            hint:
+                applicantError.hint,
+            code:
+                applicantError.code,
         });
 
         return {
@@ -183,15 +296,18 @@ export const createApplicant = async (
 
     /*
      * ---------------------------------------------------------
-     * 2. Store responses in Supabase
+     * 4. Store application responses
      * ---------------------------------------------------------
      */
 
-    const { error: responseError } = await client
+    const {
+        error: responseError,
+    } = await client
         .from("applicant_response")
         .insert([
             {
-                applicantId: applicantData.id,
+                applicantId:
+                    applicantData.id,
                 branch,
                 responses,
             },
@@ -203,14 +319,13 @@ export const createApplicant = async (
             responseError
         );
 
-        /*
-         * Roll back applicant if its responses could not
-         * be stored.
-         */
         await client
             .from("applicants")
             .delete()
-            .eq("id", applicantData.id);
+            .eq(
+                "id",
+                applicantData.id
+            );
 
         return {
             success: false,
@@ -220,12 +335,8 @@ export const createApplicant = async (
 
     /*
      * ---------------------------------------------------------
-     * 3. Sync application to Google Sheets
+     * 5. Sync application to Google Sheets
      * ---------------------------------------------------------
-     *
-     * Supabase remains the source of truth.
-     * A Google Sheets failure does NOT invalidate the
-     * application.
      */
 
     const {
@@ -237,16 +348,22 @@ export const createApplicant = async (
             body: {
                 operation: "application",
 
-                applicationId: applicantData.id,
+                applicationId:
+                    applicantData.id,
 
                 name,
+                phone,
                 sid,
                 branch,
 
-                q1: responses.Q1 || "",
-                q2: responses.Q2 || "",
-                q3: responses.Q3 || "",
-                q4: responses.Q4 || "",
+                q1:
+                    responses.Q1 || "",
+                q2:
+                    responses.Q2 || "",
+                q3:
+                    responses.Q3 || "",
+                q4:
+                    responses.Q4 || "",
             },
         }
     );
@@ -265,120 +382,289 @@ export const createApplicant = async (
         );
     }
 
-    /*
-     * ---------------------------------------------------------
-     * 4. Return successful application
-     * ---------------------------------------------------------
-     */
-
     return {
         success: true,
 
         applicant: {
             ...applicantData,
-
+            userId: user.id,
             status:
                 applicantData.status?.toLowerCase(),
-
             createdAt:
                 applicantData.createdAt ||
                 applicantData.created_at,
-
             branch,
             responses,
         } as ApplicantType,
     };
 };
 
-export const updateApplicantDecision = async (
-    applicantId: string,
-    status: "accepted" | "rejected",
-    remarks: string,
-    reviewedBy: string
-): Promise<boolean> => {
-    /*
-     * Use one timestamp for both Supabase and Google Sheets.
-     */
-    const reviewedAt = new Date().toISOString();
+/*
+ * ---------------------------------------------------------
+ * Update applicant personal information
+ *
+ * Editable:
+ *   name
+ *   phone
+ *   sid
+ *   branch
+ *
+ * Never editable:
+ *   application responses
+ *
+ * Only PENDING applications can be edited.
+ * ---------------------------------------------------------
+ */
+
+export const updateApplicantPersonalInfo =
+    async (
+        applicantId: string,
+        name: string,
+        phone: string,
+        sid: string,
+        branch: string
+    ): Promise<
+        | {
+              success: true;
+              applicant: ApplicantType;
+          }
+        | {
+              success: false;
+              reason:
+                  | "error"
+                  | "not_found";
+          }
+    > => {
+        const {
+            data: { user },
+            error: userError,
+        } = await client.auth.getUser();
+
+        if (userError || !user) {
+            return {
+                success: false,
+                reason: "error",
+            };
+        }
 
-    /*
-     * ---------------------------------------------------------
-     * 1. Update the existing applicant record
-     * ---------------------------------------------------------
-     */
+        /*
+         * Update only the personal fields.
+         *
+         * userId + id + PENDING ensures the user can only
+         * modify their own still-pending application.
+         */
+        const {
+            data,
+            error,
+        } = await client
+            .from("applicants")
+            .update({
+                name,
+                phone: phone || null,
+                sid,
+            })
+            .eq("id", applicantId)
+            .eq("userId", user.id)
+            .eq("status", "PENDING")
+            .select()
+            .single();
+
+        if (error || !data) {
+            console.error(
+                "Error updating personal information:",
+                error
+            );
 
-    const { error } = await client
-        .from("applicants")
-        .update({
-            status: status.toUpperCase(),
-            remarks,
-            reviewedBy,
-            reviewedAt,
-        })
-        .eq("id", applicantId);
+            return {
+                success: false,
+                reason:
+                    error?.code ===
+                    "PGRST116"
+                        ? "not_found"
+                        : "error",
+            };
+        }
 
-    if (error) {
-        console.error(
-            "Error updating applicant decision:",
-            error
-        );
+        /*
+         * Branch lives in applicant_response.
+         */
+        const {
+            error: branchError,
+        } = await client
+            .from("applicant_response")
+            .update({
+                branch,
+            })
+            .eq(
+                "applicantId",
+                applicantId
+            );
 
-        return false;
-    }
+        if (branchError) {
+            console.error(
+                "Error updating applicant branch:",
+                branchError
+            );
 
-    /*
-     * ---------------------------------------------------------
-     * 2. Sync decision to Results Google Sheet
-     * ---------------------------------------------------------
-     *
-     * We send only data already present in the
-     * existing application architecture.
-     *
-     * The Edge Function uses applicantId to obtain
-     * the applicant's name, SID and branch.
-     */
+            return {
+                success: false,
+                reason: "error",
+            };
+        }
 
-    const {
-        data: sheetsData,
-        error: sheetsError,
-    } = await client.functions.invoke(
-        "sync-application-to-sheets",
-        {
-            body: {
-                operation: "result",
+        /*
+         * Sync the updated personal information
+         * to the existing application row in Sheets.
+         */
+        const {
+            data: sheetsData,
+            error: sheetsError,
+        } = await client.functions.invoke(
+            "sync-application-to-sheets",
+            {
+                body: {
+                    operation:
+                        "update_application",
+
+                    applicationId:
+                        applicantId,
+
+                    name,
+                    phone,
+                    sid,
+                    branch,
+                },
+            }
+        );
+
+        if (sheetsError) {
+            console.error(
+                "Personal information updated in Supabase, but Google Sheets synchronization failed:",
+                sheetsError
+            );
+        } else if (
+            sheetsData?.success === false
+        ) {
+            console.error(
+                "Google Sheets personal information synchronization failed:",
+                sheetsData
+            );
+        }
+
+        /*
+         * Return the complete updated application.
+         */
+        const {
+            data: completeApplicant,
+            error: fetchError,
+        } = await client
+            .from("applicants")
+            .select(
+                "*, applicant_response(branch, responses)"
+            )
+            .eq("id", applicantId)
+            .eq("userId", user.id)
+            .single();
+
+        if (
+            fetchError ||
+            !completeApplicant
+        ) {
+            return {
+                success: false,
+                reason: "error",
+            };
+        }
 
-                applicationId: applicantId,
+        return {
+            success: true,
+            applicant:
+                mapApplicant(
+                    completeApplicant
+                ),
+        };
+    };
 
-                status,
+/*
+ * ---------------------------------------------------------
+ * Panelist / Admin decision
+ * ---------------------------------------------------------
+ */
+
+export const updateApplicantDecision =
+    async (
+        applicantId: string,
+        status:
+            | "accepted"
+            | "rejected",
+        remarks: string,
+        reviewedBy: string
+    ): Promise<boolean> => {
+        const reviewedAt =
+            new Date().toISOString();
+
+        const { error } = await client
+            .from("applicants")
+            .update({
+                status:
+                    status.toUpperCase(),
                 remarks,
                 reviewedBy,
                 reviewedAt,
-            },
+            })
+            .eq(
+                "id",
+                applicantId
+            );
+
+        if (error) {
+            console.error(
+                "Error updating applicant decision:",
+                error
+            );
+
+            return false;
         }
-    );
 
-    /*
-     * Supabase remains the source of truth.
-     * Do NOT undo a valid decision because Sheets
-     * synchronization failed.
-     */
+        /*
+         * Sync decision to Results Sheet.
+         */
+        const {
+            data: sheetsData,
+            error: sheetsError,
+        } = await client.functions.invoke(
+            "sync-application-to-sheets",
+            {
+                body: {
+                    operation: "result",
 
-    if (sheetsError) {
-        console.error(
-            "Decision saved to Supabase, but Results Sheet synchronization failed:",
-            sheetsError
-        );
-    } else if (
-        sheetsData?.success === false
-    ) {
-        console.error(
-            "Results Sheet synchronization failed:",
-            sheetsData
+                    applicationId:
+                        applicantId,
+
+                    status,
+                    remarks,
+                    reviewedBy,
+                    reviewedAt,
+                },
+            }
         );
-    }
 
-    return true;
-};
+        if (sheetsError) {
+            console.error(
+                "Decision saved to Supabase, but Results Sheet synchronization failed:",
+                sheetsError
+            );
+        } else if (
+            sheetsData?.success === false
+        ) {
+            console.error(
+                "Results Sheet synchronization failed:",
+                sheetsData
+            );
+        }
+
+        return true;
+    };
 
 export const subscribeToApplicantUpdates = (
     onUpdate: (
diff --git a/src/types/index.d.ts b/src/types/index.d.ts
index d3c9f70..275481d 100644
--- a/src/types/index.d.ts
+++ b/src/types/index.d.ts
@@ -152,6 +152,8 @@ export interface TeamData {
 
 export interface ApplicantType {
     id: string;
+    userId?: string;
+
     name: string;
     sid: string;
     phone?: string;
diff --git a/supabase/functions/sync-application-to-sheets/index.ts b/supabase/functions/sync-application-to-sheets/index.ts
index 2ab70d9..49bca8d 100644
--- a/supabase/functions/sync-application-to-sheets/index.ts
+++ b/supabase/functions/sync-application-to-sheets/index.ts
@@ -10,9 +10,9 @@ const corsHeaders = {
 
 type ApplicationOperation = {
     operation: "application";
-
     applicationId: string;
     name: string;
+    phone: string;
     sid: string;
     branch: string;
     q1: string;
@@ -21,9 +21,17 @@ type ApplicationOperation = {
     q4: string;
 };
 
+type UpdateApplicationOperation = {
+    operation: "update_application";
+    applicationId: string;
+    name: string;
+    phone: string;
+    sid: string;
+    branch: string;
+};
+
 type ResultOperation = {
     operation: "result";
-
     applicationId: string;
     status: "accepted" | "rejected";
     remarks: string;
@@ -33,15 +41,10 @@ type ResultOperation = {
 
 type RequestData =
     | ApplicationOperation
+    | UpdateApplicationOperation
     | ResultOperation;
 
 Deno.serve(async (req: Request) => {
-    /*
-     * ---------------------------------------------------------
-     * CORS preflight
-     * ---------------------------------------------------------
-     */
-
     if (req.method === "OPTIONS") {
         return new Response("ok", {
             headers: corsHeaders,
@@ -58,27 +61,25 @@ Deno.serve(async (req: Request) => {
                 status: 405,
                 headers: {
                     ...corsHeaders,
-                    "Content-Type": "application/json",
+                    "Content-Type":
+                        "application/json",
                 },
             }
         );
     }
 
     try {
-        /*
-         * ---------------------------------------------------------
-         * 1. Verify authenticated Supabase user
-         * ---------------------------------------------------------
-         */
-
         const authorization =
-            req.headers.get("Authorization");
+            req.headers.get(
+                "Authorization"
+            );
 
         if (!authorization) {
             return new Response(
                 JSON.stringify({
                     success: false,
-                    error: "Authentication required",
+                    error:
+                        "Authentication required",
                 }),
                 {
                     status: 401,
@@ -92,36 +93,48 @@ Deno.serve(async (req: Request) => {
         }
 
         const supabaseUrl =
-            Deno.env.get("SUPABASE_URL");
+            Deno.env.get(
+                "SUPABASE_URL"
+            );
 
         const supabaseAnonKey =
-            Deno.env.get("SUPABASE_ANON_KEY");
+            Deno.env.get(
+                "SUPABASE_ANON_KEY"
+            );
 
-        if (!supabaseUrl || !supabaseAnonKey) {
+        if (
+            !supabaseUrl ||
+            !supabaseAnonKey
+        ) {
             throw new Error(
                 "Supabase environment variables are missing"
             );
         }
 
-        const supabase = createClient(
-            supabaseUrl,
-            supabaseAnonKey,
-            {
-                global: {
-                    headers: {
-                        Authorization:
-                            authorization,
+        const supabase =
+            createClient(
+                supabaseUrl,
+                supabaseAnonKey,
+                {
+                    global: {
+                        headers: {
+                            Authorization:
+                                authorization,
+                        },
                     },
-                },
-            }
-        );
+                }
+            );
 
         const {
             data: { user },
             error: userError,
-        } = await supabase.auth.getUser();
+        } =
+            await supabase.auth.getUser();
 
-        if (userError || !user) {
+        if (
+            userError ||
+            !user
+        ) {
             return new Response(
                 JSON.stringify({
                     success: false,
@@ -139,12 +152,6 @@ Deno.serve(async (req: Request) => {
             );
         }
 
-        /*
-         * ---------------------------------------------------------
-         * 2. Parse request
-         * ---------------------------------------------------------
-         */
-
         const data =
             (await req.json()) as RequestData;
 
@@ -166,12 +173,6 @@ Deno.serve(async (req: Request) => {
             );
         }
 
-        /*
-         * ---------------------------------------------------------
-         * 3. Read Google configuration
-         * ---------------------------------------------------------
-         */
-
         const googleScriptUrl =
             Deno.env.get(
                 "GOOGLE_SHEETS_SCRIPT_URL"
@@ -193,37 +194,43 @@ Deno.serve(async (req: Request) => {
 
         /*
          * ---------------------------------------------------------
-         * 4. APPLICATION OPERATION
+         * APPLICATION
          * ---------------------------------------------------------
-         *
-         * Existing behavior:
-         * write the application to the current academic-year
-         * application sheet.
          */
 
-        if (data.operation === "application") {
+        if (
+            data.operation ===
+            "application"
+        ) {
             const application =
                 data as ApplicationOperation;
 
-            const requiredFields: (
-                keyof ApplicationOperation
-            )[] = [
+            const requiredFields = [
                 "applicationId",
                 "name",
+                "phone",
                 "sid",
                 "branch",
                 "q1",
                 "q2",
                 "q3",
                 "q4",
-            ];
+            ] as const;
 
-            for (const field of requiredFields) {
+            for (
+                const field of
+                requiredFields
+            ) {
                 if (
-                    application[field] === undefined ||
-                    application[field] === null ||
-                    String(application[field])
-                        .trim() === ""
+                    application[
+                        field
+                    ] === undefined ||
+                    application[
+                        field
+                    ] === null ||
+                    String(
+                        application[field]
+                    ).trim() === ""
                 ) {
                     return new Response(
                         JSON.stringify({
@@ -262,6 +269,9 @@ Deno.serve(async (req: Request) => {
                             name:
                                 application.name,
 
+                            phone:
+                                application.phone,
+
                             sid:
                                 application.sid,
 
@@ -283,7 +293,8 @@ Deno.serve(async (req: Request) => {
                             secret:
                                 googleSheetsSecret,
 
-                            userId: user.id,
+                            userId:
+                                user.id,
                         }),
                     }
                 );
@@ -309,14 +320,15 @@ Deno.serve(async (req: Request) => {
             ) {
                 throw new Error(
                     googleResult.error ||
-                    `Google Sheets synchronization failed (HTTP ${googleResponse.status})`
+                        `Google Sheets synchronization failed (HTTP ${googleResponse.status})`
                 );
             }
 
             return new Response(
                 JSON.stringify({
                     success: true,
-                    operation: "application",
+                    operation:
+                        "application",
                     duplicate:
                         googleResult.duplicate ??
                         false,
@@ -334,34 +346,211 @@ Deno.serve(async (req: Request) => {
 
         /*
          * ---------------------------------------------------------
-         * 5. RESULT OPERATION
+         * UPDATE APPLICATION
          * ---------------------------------------------------------
          *
-         * We do NOT ask the frontend to send name/SID/branch.
-         *
-         * We fetch those from the existing Supabase data using
-         * the existing application ID.
-         *
-         * This avoids duplicating data sources.
+         * Updates only Name / Phone / SID / Branch.
+         * Submitted answers are never changed.
+         */
+
+        if (
+            data.operation ===
+            "update_application"
+        ) {
+            const update =
+                data as UpdateApplicationOperation;
+
+            const {
+                data: applicant,
+                error: applicantError,
+            } = await supabase
+                .from("applicants")
+                .select(
+                    "id, userId, status"
+                )
+                .eq(
+                    "id",
+                    update.applicationId
+                )
+                .eq(
+                    "userId",
+                    user.id
+                )
+                .eq(
+                    "status",
+                    "PENDING"
+                )
+                .single();
+
+            if (
+                applicantError ||
+                !applicant
+            ) {
+                return new Response(
+                    JSON.stringify({
+                        success: false,
+                        error:
+                            "Application not found or no longer editable",
+                    }),
+                    {
+                        status: 404,
+                        headers: {
+                            ...corsHeaders,
+                            "Content-Type":
+                                "application/json",
+                        },
+                    }
+                );
+            }
+
+            const requiredFields = [
+                "applicationId",
+                "name",
+                "phone",
+                "sid",
+                "branch",
+            ] as const;
+
+            for (
+                const field of
+                requiredFields
+            ) {
+                if (
+                    update[field] ===
+                        undefined ||
+                    update[field] ===
+                        null ||
+                    String(
+                        update[field]
+                    ).trim() === ""
+                ) {
+                    return new Response(
+                        JSON.stringify({
+                            success: false,
+                            error:
+                                `Missing required field: ${field}`,
+                        }),
+                        {
+                            status: 400,
+                            headers: {
+                                ...corsHeaders,
+                                "Content-Type":
+                                    "application/json",
+                            },
+                        }
+                    );
+                }
+            }
+
+            const googleResponse =
+                await fetch(
+                    googleScriptUrl,
+                    {
+                        method: "POST",
+                        headers: {
+                            "Content-Type":
+                                "application/json",
+                        },
+                        body: JSON.stringify({
+                            operation:
+                                "update_application",
+
+                            applicationId:
+                                update.applicationId,
+
+                            name:
+                                update.name,
+
+                            phone:
+                                update.phone,
+
+                            sid:
+                                update.sid,
+
+                            branch:
+                                update.branch,
+
+                            secret:
+                                googleSheetsSecret,
+
+                            userId:
+                                user.id,
+                        }),
+                    }
+                );
+
+            let googleResult: {
+                success?: 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 ||
+                        `Google Sheets synchronization failed (HTTP ${googleResponse.status})`
+                );
+            }
+
+            return new Response(
+                JSON.stringify({
+                    success: true,
+                    operation:
+                        "update_application",
+                }),
+                {
+                    status: 200,
+                    headers: {
+                        ...corsHeaders,
+                        "Content-Type":
+                            "application/json",
+                    },
+                }
+            );
+        }
+
+        /*
+         * ---------------------------------------------------------
+         * RESULT
+         * ---------------------------------------------------------
          */
 
-        if (data.operation === "result") {
+        if (
+            data.operation ===
+            "result"
+        ) {
             const result =
                 data as ResultOperation;
 
-            const { data: applicant, error } =
-                await supabase
-                    .from("applicants")
-                    .select(
-                        "id, name, sid, isWalkin, applicant_response(branch)"
-                    )
-                    .eq(
-                        "id",
-                        result.applicationId
-                    )
-                    .single();
-
-            if (error || !applicant) {
+            const {
+                data: applicant,
+                error,
+            } = await supabase
+                .from("applicants")
+                .select(
+                    "id, name, phone, sid, isWalkin, applicant_response(branch)"
+                )
+                .eq(
+                    "id",
+                    result.applicationId
+                )
+                .single();
+
+            if (
+                error ||
+                !applicant
+            ) {
                 throw new Error(
                     "Could not fetch applicant for result sheet"
                 );
@@ -377,12 +566,8 @@ Deno.serve(async (req: Request) => {
                     : response;
 
             const branch =
-                responseData?.branch || "";
-
-            /*
-             * Send the existing decision data + existing
-             * applicant information to Apps Script.
-             */
+                responseData?.branch ||
+                "";
 
             const googleResponse =
                 await fetch(
@@ -394,7 +579,8 @@ Deno.serve(async (req: Request) => {
                                 "application/json",
                         },
                         body: JSON.stringify({
-                            operation: "result",
+                            operation:
+                                "result",
 
                             applicationId:
                                 result.applicationId,
@@ -402,6 +588,10 @@ Deno.serve(async (req: Request) => {
                             name:
                                 applicant.name,
 
+                            phone:
+                                applicant.phone ||
+                                "",
+
                             sid:
                                 applicant.sid,
 
@@ -411,7 +601,8 @@ Deno.serve(async (req: Request) => {
                                 result.status,
 
                             remarks:
-                                result.remarks || "",
+                                result.remarks ||
+                                "",
 
                             reviewedBy:
                                 result.reviewedBy,
@@ -422,7 +613,8 @@ Deno.serve(async (req: Request) => {
                             secret:
                                 googleSheetsSecret,
 
-                            userId: user.id,
+                            userId:
+                                user.id,
                         }),
                     }
                 );
@@ -447,14 +639,15 @@ Deno.serve(async (req: Request) => {
             ) {
                 throw new Error(
                     googleResult.error ||
-                    `Results Sheet synchronization failed (HTTP ${googleResponse.status})`
+                        `Results Sheet synchronization failed (HTTP ${googleResponse.status})`
                 );
             }
 
             return new Response(
                 JSON.stringify({
                     success: true,
-                    operation: "result",
+                    operation:
+                        "result",
                 }),
                 {
                     status: 200,
@@ -467,10 +660,6 @@ Deno.serve(async (req: Request) => {
             );
         }
 
-        /*
-         * Unknown operation
-         */
-
         return new Response(
             JSON.stringify({
                 success: false,
@@ -486,7 +675,6 @@ Deno.serve(async (req: Request) => {
                 },
             }
         );
-
     } catch (error) {
         console.error(
             "sync-application-to-sheets error:",