diff --git a/src/components/CommunityPortal/Activities/__tests__/ActivityList.test.jsx b/src/components/CommunityPortal/Activities/__tests__/ActivityList.test.jsx
index d5751c59432..f0b1639a039 100644
--- a/src/components/CommunityPortal/Activities/__tests__/ActivityList.test.jsx
+++ b/src/components/CommunityPortal/Activities/__tests__/ActivityList.test.jsx
@@ -57,6 +57,7 @@ describe('ActivityList', () => {
 
   test('sorts activities by date (latest to earliest)', () => {
     renderActivityList();
+    fireEvent.click(screen.getByLabelText(/Show Past Events:/i));
 
     fireEvent.change(screen.getByLabelText(/Sort By:/i), {
       target: { value: 'latest' },
diff --git a/src/components/PRGradingScreen/PRGradingScreen.duplicates.test.jsx b/src/components/PRGradingScreen/PRGradingScreen.duplicates.test.jsx
new file mode 100644
index 00000000000..c67eabfdf09
--- /dev/null
+++ b/src/components/PRGradingScreen/PRGradingScreen.duplicates.test.jsx
@@ -0,0 +1,196 @@
+import { fireEvent, render, screen, waitFor, within } from '@testing-library/react';
+import axios from 'axios';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import PRGradingScreen from './PRGradingScreen';
+
+vi.mock('axios');
+vi.mock('react-redux', () => ({
+  useSelector: selector => selector({ theme: { darkMode: false } }),
+}));
+
+const teamData = {
+  teamName: 'Test Team',
+  dateRange: { start: '5/18/2025', end: '5/25/2025' },
+};
+const reviewers = [
+  {
+    id: '1',
+    reviewer: 'Alice',
+    prsNeeded: 3,
+    gradedPrs: [{ id: 'pr1', prNumbers: '1234 + 5678', grade: 'Okay' }],
+  },
+  { id: '2', reviewer: 'Bob', prsNeeded: 3, gradedPrs: [] },
+];
+
+const addPR = async (row, numbers) => {
+  const addNewButton = within(row).getByRole('button', { name: '+ Add new' });
+  await waitFor(() => expect(addNewButton).toBeEnabled());
+  fireEvent.click(addNewButton);
+  fireEvent.change(within(row).getByPlaceholderText('1070 or 1070 + 1256'), {
+    target: { value: numbers },
+  });
+  fireEvent.click(within(row).getByRole('button', { name: 'Add' }));
+  await waitFor(() =>
+    expect(within(row).queryByRole('button', { name: 'Adding...' })).not.toBeInTheDocument(),
+  );
+};
+
+describe('Weekly PR grading duplicate entries', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    axios.get.mockResolvedValue({ data: [] });
+    axios.post.mockResolvedValue({ data: { status: 'ok' } });
+  });
+
+  it('allows a pair containing two unused PR numbers and counts it as one review', async () => {
+    render(<PRGradingScreen teamData={teamData} reviewers={reviewers} />);
+    const aliceRow = screen.getByRole('row', { name: /Alice/ });
+
+    await addPR(aliceRow, '9981 + 9982');
+
+    expect(within(aliceRow).getByText('9981 + 9982')).toBeInTheDocument();
+    expect(within(aliceRow).getByRole('spinbutton')).toHaveValue(2);
+    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+  });
+
+  it('rejects a PR already present inside a pair for the same reviewer', async () => {
+    render(<PRGradingScreen teamData={teamData} reviewers={reviewers} />);
+    const aliceRow = screen.getByRole('row', { name: /Alice/ });
+
+    await addPR(aliceRow, '5678 + 9999');
+
+    expect(screen.getByRole('alert')).toHaveTextContent('already been added');
+    expect(within(aliceRow).getByRole('spinbutton')).toHaveValue(1);
+    expect(within(aliceRow).queryByText('5678 + 9999')).not.toBeInTheDocument();
+  });
+
+  it('rejects a repeated number within a new pair', async () => {
+    render(<PRGradingScreen teamData={teamData} reviewers={reviewers} />);
+    const aliceRow = screen.getByRole('row', { name: /Alice/ });
+
+    await addPR(aliceRow, '4321 + 4321');
+
+    expect(screen.getByRole('alert')).toHaveTextContent('already been added');
+    expect(within(aliceRow).getByRole('spinbutton')).toHaveValue(1);
+  });
+
+  it('rejects a repeated addition but allows another reviewer to use that PR number', async () => {
+    render(<PRGradingScreen teamData={teamData} reviewers={reviewers} />);
+    const aliceRow = screen.getByRole('row', { name: /Alice/ });
+    const bobRow = screen.getByRole('row', { name: /Bob/ });
+
+    await addPR(aliceRow, '4321');
+    await addPR(aliceRow, '4321');
+
+    expect(screen.getByRole('alert')).toHaveTextContent('already been added');
+    expect(within(aliceRow).getByRole('spinbutton')).toHaveValue(2);
+
+    await addPR(bobRow, '4321');
+    expect(within(bobRow).getByRole('spinbutton')).toHaveValue(1);
+  });
+
+  it('loads a saved PR again after the screen is remounted', async () => {
+    axios.get
+      .mockResolvedValueOnce({ data: [] })
+      .mockResolvedValueOnce({ data: [] })
+      .mockResolvedValueOnce({
+        data: [
+          {
+            reviewer: 'Alice',
+            gradedPrs: [{ _id: 'saved1', prNumbers: '9981', grade: 'Okay' }],
+          },
+        ],
+      });
+    const { unmount } = render(<PRGradingScreen teamData={teamData} reviewers={reviewers} />);
+    await addPR(screen.getByRole('row', { name: /Alice/ }), '9981');
+    unmount();
+
+    render(<PRGradingScreen teamData={teamData} reviewers={reviewers} />);
+    const aliceRow = screen.getByRole('row', { name: /Alice/ });
+    await waitFor(() => expect(within(aliceRow).getByText('9981')).toBeInTheDocument());
+    expect(within(aliceRow).getByRole('spinbutton')).toHaveValue(2);
+  });
+
+  it('keeps the input open when saving fails instead of showing an unsaved PR', async () => {
+    axios.post.mockRejectedValueOnce(new Error('Network error'));
+    render(<PRGradingScreen teamData={teamData} reviewers={reviewers} />);
+    const aliceRow = screen.getByRole('row', { name: /Alice/ });
+
+    await addPR(aliceRow, '9981');
+
+    expect(within(aliceRow).getByRole('alert')).toHaveTextContent('Could not save');
+    expect(within(aliceRow).getByRole('spinbutton')).toHaveValue(1);
+    expect(within(aliceRow).queryByText('9981')).not.toBeInTheDocument();
+  });
+
+  it('saves a changed grade and restores it after remounting', async () => {
+    axios.get.mockResolvedValueOnce({ data: [] }).mockResolvedValueOnce({
+      data: [
+        {
+          reviewer: 'Alice',
+          gradedPrs: [{ prNumbers: '1234 + 5678', grade: 'Exceptional' }],
+        },
+      ],
+    });
+    const { unmount } = render(<PRGradingScreen teamData={teamData} reviewers={reviewers} />);
+    await waitFor(() =>
+      expect(
+        within(screen.getByRole('row', { name: /Alice/ })).getByText('+ Add new'),
+      ).toBeEnabled(),
+    );
+    fireEvent.click(within(screen.getByRole('row', { name: /Alice/ })).getByText('1234 + 5678'));
+    fireEvent.click(screen.getAllByRole('checkbox')[0]);
+
+    await waitFor(() => expect(axios.post).toHaveBeenCalledTimes(1));
+    expect(axios.post.mock.calls[0][1].gradings[0].gradedPrs).toEqual([
+      { prNumbers: '1234 + 5678', grade: 'Exceptional' },
+    ]);
+    await waitFor(() => expect(screen.getAllByRole('checkbox')[0]).toBeChecked());
+    unmount();
+
+    render(<PRGradingScreen teamData={teamData} reviewers={reviewers} />);
+    await waitFor(() => expect(axios.get).toHaveBeenCalledTimes(2));
+    fireEvent.click(within(screen.getByRole('row', { name: /Alice/ })).getByText('1234 + 5678'));
+    await waitFor(() => expect(screen.getAllByRole('checkbox')[0]).toBeChecked());
+    expect(within(screen.getByRole('row', { name: /Alice/ })).getByRole('spinbutton')).toHaveValue(
+      1,
+    );
+  });
+
+  it('keeps the previous grade and shows an error if saving fails', async () => {
+    axios.post.mockRejectedValueOnce(new Error('Network error'));
+    render(<PRGradingScreen teamData={teamData} reviewers={reviewers} />);
+    await waitFor(() =>
+      expect(
+        within(screen.getByRole('row', { name: /Alice/ })).getByText('+ Add new'),
+      ).toBeEnabled(),
+    );
+    fireEvent.click(within(screen.getByRole('row', { name: /Alice/ })).getByText('1234 + 5678'));
+    fireEvent.click(screen.getAllByRole('checkbox')[0]);
+
+    expect(await screen.findByRole('alert')).toHaveTextContent('Could not save this grade');
+    expect(axios.post.mock.calls[0][1].gradings[0].gradedPrs).toEqual([
+      { prNumbers: '1234 + 5678', grade: 'Exceptional' },
+    ]);
+    expect(screen.getAllByRole('checkbox')[0]).not.toBeChecked();
+    expect(screen.getAllByRole('checkbox')[1]).toBeChecked();
+  });
+
+  it('sends the backend-supported value for Cannot find image', async () => {
+    render(<PRGradingScreen teamData={teamData} reviewers={reviewers} />);
+    await waitFor(() =>
+      expect(
+        within(screen.getByRole('row', { name: /Alice/ })).getByText('+ Add new'),
+      ).toBeEnabled(),
+    );
+    fireEvent.click(within(screen.getByRole('row', { name: /Alice/ })).getByText('1234 + 5678'));
+    fireEvent.click(screen.getAllByRole('checkbox')[3]);
+
+    await waitFor(() =>
+      expect(axios.post.mock.calls[0][1].gradings[0].gradedPrs).toEqual([
+        { prNumbers: '1234 + 5678', grade: 'No Correct Image' },
+      ]),
+    );
+    await waitFor(() => expect(screen.getAllByRole('checkbox')[3]).toBeChecked());
+  });
+});
diff --git a/src/components/PRGradingScreen/PRGradingScreen.jsx b/src/components/PRGradingScreen/PRGradingScreen.jsx
index 25a118011c8..489a6adf9b3 100644
--- a/src/components/PRGradingScreen/PRGradingScreen.jsx
+++ b/src/components/PRGradingScreen/PRGradingScreen.jsx
@@ -1,21 +1,43 @@
-import React, { useMemo, useState } from 'react';
 import PropTypes from 'prop-types';
+import { useEffect, useMemo, useState } from 'react';
 import { useSelector } from 'react-redux';
 import { v4 as uuidv4 } from 'uuid';
 import PRGradingView from './PRGradingView';
+import {
+  loadSavedGradings,
+  mergeSavedGradings,
+  saveAddedPR,
+  saveGradeChange,
+} from './prGradingPersistence';
 import { usePRPromotion } from './usePRPromotion';
 
+const hasDuplicatePR = (gradedPrs, value) => {
+  const enteredNumbers = value.split('+').map(number => number.trim());
+  const existingNumbers = new Set(
+    gradedPrs.flatMap(pr => pr.prNumbers.split('+').map(number => number.trim())),
+  );
+  return (
+    new Set(enteredNumbers).size !== enteredNumbers.length ||
+    enteredNumbers.some(number => existingNumbers.has(number))
+  );
+};
+
 const PRGradingScreen = ({ teamData, reviewers }) => {
   const darkMode = useSelector(state => state.theme.darkMode);
-
-  // Reviewer & grading state
   const [reviewerData, setReviewerData] = useState(reviewers || []);
   const [activeInput, setActiveInput] = useState(null);
   const [inputValue, setInputValue] = useState('');
+  const [inputError, setInputError] = useState('');
   const [showGradingModal, setShowGradingModal] = useState(null);
   const [isFinalized, setIsFinalized] = useState(false);
+  const [isLoadingSaved, setIsLoadingSaved] = useState(true);
+  const [isSavingPR, setIsSavingPR] = useState(false);
+  const [isSavingGrade, setIsSavingGrade] = useState(false);
+  const [gradeError, setGradeError] = useState('');
+  const [loadError, setLoadError] = useState('');
+  const [searchTerm, setSearchTerm] = useState('');
+  const [roleFilter, setRoleFilter] = useState('');
 
-  // Promotion business logic & state from hook
   const {
     promotingReviewer,
     promotedReviewerIds,
@@ -24,102 +46,170 @@ const PRGradingScreen = ({ teamData, reviewers }) => {
     handleCancelPromotion,
   } = usePRPromotion(teamData?.teamName);
 
-  // Search filter state
-  const [searchTerm, setSearchTerm] = useState('');
-  const [roleFilter, setRoleFilter] = useState('');
-
-  /* ---------------- SEARCH FILTER ---------------- */
+  useEffect(() => {
+    if (!teamData || !reviewers) return undefined;
+    let active = true;
+    setIsLoadingSaved(true);
+    loadSavedGradings(teamData)
+      .then(saved => {
+        if (active) {
+          setReviewerData(mergeSavedGradings(reviewers, saved));
+          setLoadError('');
+        }
+      })
+      .catch(() => {
+        if (active) setLoadError('Could not load saved PRs. Try again before adding a PR.');
+      })
+      .finally(() => {
+        if (active) setIsLoadingSaved(false);
+      });
+    return () => {
+      active = false;
+    };
+  }, [teamData, reviewers]);
 
   const availableRoles = useMemo(() => {
-    const roles = reviewerData.map(r => r.role).filter(Boolean);
+    const roles = reviewerData.map(reviewer => reviewer.role).filter(Boolean);
     return [...new Set(roles)];
   }, [reviewerData]);
 
-  const filteredReviewers = useMemo(() => {
-    return reviewerData.filter(r => {
-      const nameMatch = r.reviewer.toLowerCase().includes(searchTerm.toLowerCase());
-      const roleMatch = roleFilter ? r.role === roleFilter : true;
-      return nameMatch && roleMatch;
-    });
-  }, [reviewerData, searchTerm, roleFilter]);
+  const filteredReviewers = useMemo(
+    () =>
+      reviewerData.filter(reviewer => {
+        const nameMatch = reviewer.reviewer.toLowerCase().includes(searchTerm.toLowerCase());
+        const roleMatch = roleFilter ? reviewer.role === roleFilter : true;
+        return nameMatch && roleMatch;
+      }),
+    [reviewerData, searchTerm, roleFilter],
+  );
 
   const handleClearSearch = () => {
     setSearchTerm('');
     setRoleFilter('');
   };
 
-  /* ---------------- ADD PR HANDLERS ---------------- */
-
   const validatePRNumber = value => {
     const trimmed = value.trim();
     const pattern = /^\d+(\s*\+\s*\d+)?$/;
-    if (!trimmed) return false;
-    return pattern.test(trimmed);
+    if (!trimmed) return { isValid: false, error: 'PR number cannot be empty' };
+    if (!pattern.test(trimmed)) return { isValid: false, error: 'Format: 1070 or 1070 + 1256' };
+    return { isValid: true, error: '' };
   };
 
   const handleAddNewClick = reviewerId => {
-    if (isFinalized) return;
+    if (isFinalized || isLoadingSaved || loadError) return;
     setActiveInput(reviewerId);
     setInputValue('');
+    setInputError('');
   };
 
-  const handleInputSubmit = reviewerId => {
-    if (isFinalized) return;
-    if (!validatePRNumber(inputValue)) {
+  const handleInputSubmit = async reviewerId => {
+    if (isFinalized || isLoadingSaved || isSavingPR || loadError) return;
+    const validation = validatePRNumber(inputValue);
+    if (!validation.isValid) {
+      setInputError(validation.error);
       return;
     }
-    const newPREntry = { id: uuidv4(), prNumbers: inputValue.trim(), grade: 'Okay' };
-    setReviewerData(prev =>
-      prev.map(r =>
-        r.id === reviewerId
-          ? { ...r, gradedPrs: [...r.gradedPrs, newPREntry], prsReviewed: r.gradedPrs.length + 1 }
-          : r,
-      ),
-    );
-    setActiveInput(null);
-    setInputValue('');
+    const reviewer = reviewerData.find(item => item.id === reviewerId);
+    if (!reviewer) return;
+    if (hasDuplicatePR(reviewer.gradedPrs, inputValue)) {
+      setInputError('This PR number has already been added for this reviewer.');
+      return;
+    }
+
+    setIsSavingPR(true);
+    try {
+      const saved = await loadSavedGradings(teamData);
+      const currentReviewers = mergeSavedGradings(reviewerData, saved);
+      const currentReviewer = currentReviewers.find(item => item.id === reviewerId);
+      if (!currentReviewer) return;
+      if (hasDuplicatePR(currentReviewer.gradedPrs, inputValue)) {
+        setReviewerData(currentReviewers);
+        setInputError('This PR number has already been added for this reviewer.');
+        return;
+      }
+
+      const prNumbers = inputValue.trim();
+      await saveAddedPR(teamData, currentReviewer, prNumbers);
+      const newPREntry = { id: uuidv4(), prNumbers, grade: 'Okay' };
+      setReviewerData(
+        currentReviewers.map(item =>
+          item.id === reviewerId
+            ? {
+                ...item,
+                gradedPrs: [...item.gradedPrs, newPREntry],
+                prsReviewed: item.gradedPrs.length + 1,
+              }
+            : item,
+        ),
+      );
+      setActiveInput(null);
+      setInputValue('');
+      setInputError('');
+    } catch {
+      setInputError('Could not save this PR. Please try again.');
+    } finally {
+      setIsSavingPR(false);
+    }
   };
 
   const handleCancelInput = () => {
-    if (isFinalized) return;
+    if (isFinalized || isSavingPR) return;
     setActiveInput(null);
     setInputValue('');
+    setInputError('');
   };
 
-  /* ---------------- MODAL HANDLERS ---------------- */
-
   const handlePRNumberClick = reviewerId => {
-    if (isFinalized) return;
+    if (isFinalized || isLoadingSaved || loadError) return;
+    setGradeError('');
     setShowGradingModal(reviewerId);
   };
 
-  const handleGradeChange = (reviewerId, prId, newGrade) => {
-    if (isFinalized) return;
-    setReviewerData(prev =>
-      prev.map(r =>
-        r.id === reviewerId
-          ? {
-              ...r,
-              gradedPrs: r.gradedPrs.map(pr => (pr.id === prId ? { ...pr, grade: newGrade } : pr)),
-            }
-          : r,
-      ),
-    );
+  const handleGradeChange = async (reviewerId, prId, newGrade) => {
+    if (isFinalized || isLoadingSaved || isSavingGrade || loadError) return;
+    const reviewer = reviewerData.find(item => item.id === reviewerId);
+    const pr = reviewer?.gradedPrs.find(item => item.id === prId);
+    if (!pr || pr.grade === newGrade) return;
+
+    setIsSavingGrade(true);
+    setGradeError('');
+    try {
+      const savedGrade = newGrade === 'Cannot find image' ? 'No Correct Image' : newGrade;
+      await saveGradeChange(teamData, reviewer, pr.prNumbers, savedGrade);
+      setReviewerData(prev =>
+        prev.map(item =>
+          item.id === reviewerId
+            ? {
+                ...item,
+                gradedPrs: item.gradedPrs.map(gradedPR =>
+                  gradedPR.id === prId ? { ...gradedPR, grade: newGrade } : gradedPR,
+                ),
+              }
+            : item,
+        ),
+      );
+    } catch {
+      setGradeError('Could not save this grade. Please try again.');
+    } finally {
+      setIsSavingGrade(false);
+    }
   };
 
-  const handleCloseGradingModal = () => setShowGradingModal(null);
-  const handleFinalize = () => setIsFinalized(true);
+  const handleCloseGradingModal = () => {
+    if (isSavingGrade) return;
+    setShowGradingModal(null);
+    setGradeError('');
+  };
 
-  if (!teamData || !reviewers) {
-    return <div>Error: Missing required props</div>;
-  }
+  if (!teamData || !reviewers) return <div>Error: Missing required props</div>;
 
   return (
     <PRGradingView
       darkMode={darkMode}
       teamData={teamData}
       isFinalized={isFinalized}
-      onFinalize={handleFinalize}
+      onFinalize={() => setIsFinalized(true)}
       searchTerm={searchTerm}
       onSearchTermChange={setSearchTerm}
       roleFilter={roleFilter}
@@ -131,7 +221,16 @@ const PRGradingScreen = ({ teamData, reviewers }) => {
       onPromoteClick={handlePromoteClick}
       activeInput={activeInput}
       inputValue={inputValue}
-      onInputValueChange={setInputValue}
+      inputError={inputError}
+      loadError={loadError}
+      gradeError={gradeError}
+      isLoadingSaved={isLoadingSaved}
+      isSavingPR={isSavingPR}
+      isSavingGrade={isSavingGrade}
+      onInputValueChange={value => {
+        setInputValue(value);
+        setInputError('');
+      }}
       onAddNewClick={handleAddNewClick}
       onInputSubmit={handleInputSubmit}
       onCancelInput={handleCancelInput}
@@ -141,7 +240,7 @@ const PRGradingScreen = ({ teamData, reviewers }) => {
       onCancelPromotion={handleCancelPromotion}
       showGradingModal={showGradingModal}
       onCloseGradingModal={handleCloseGradingModal}
-      gradingReviewer={reviewerData.find(r => r.id === showGradingModal)}
+      gradingReviewer={reviewerData.find(reviewer => reviewer.id === showGradingModal)}
       onGradeChange={handleGradeChange}
     />
   );
diff --git a/src/components/PRGradingScreen/PRGradingScreen.module.css b/src/components/PRGradingScreen/PRGradingScreen.module.css
index adfff57b389..38e40fb9641 100644
--- a/src/components/PRGradingScreen/PRGradingScreen.module.css
+++ b/src/components/PRGradingScreen/PRGradingScreen.module.css
@@ -381,7 +381,7 @@
 }
 
 .pr-grading-screen-error-message {
-  color: #f8d7da;
+  color: #b02a37;
   font-size: 0.75rem;
   margin-top: 4px;
   text-align: center;
@@ -989,6 +989,10 @@
   color: #9ab0cc;
 }
 
+.pr-grading-screen-error-message.dark-mode {
+  color: #f8d7da;
+}
+
 /* Promotion Confirmation Modal Actions (From Your Branch) */
 .pr-promotion-no-history {
   margin-bottom: 16px;
@@ -1247,4 +1251,4 @@
     padding: 2px 6px;
     font-size: 12px;
   }
-}
\ No newline at end of file
+}
diff --git a/src/components/PRGradingScreen/PRGradingScreenContainer.test.jsx b/src/components/PRGradingScreen/PRGradingScreenContainer.test.jsx
new file mode 100644
index 00000000000..448cef10efd
--- /dev/null
+++ b/src/components/PRGradingScreen/PRGradingScreenContainer.test.jsx
@@ -0,0 +1,49 @@
+import { render, screen } from '@testing-library/react';
+import axios from 'axios';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import PRGradingScreenContainer from './index';
+
+const route = vi.hoisted(() => ({ search: '', state: null }));
+
+vi.mock('axios');
+vi.mock('react-router-dom', () => ({ useLocation: () => route }));
+vi.mock('./PRGradingScreen', () => ({
+  default: ({ teamData, reviewers }) => (
+    <div>
+      {teamData.teamName} - {teamData.dateRange.start} - {reviewers.length} reviewers
+    </div>
+  ),
+}));
+
+describe('PR grading screen team selection', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    route.search = '';
+    route.state = null;
+  });
+
+  it('loads the built-in team when opened directly', () => {
+    render(<PRGradingScreenContainer />);
+
+    expect(screen.getByText(/91NePRT - 5\/18\/2025/)).toBeInTheDocument();
+    expect(axios.get).not.toHaveBeenCalled();
+  });
+
+  it('reloads a custom team from its URL after a refresh', async () => {
+    route.search = '?teamId=custom1&weekStart=2026-10-04';
+    axios.get.mockResolvedValue({
+      data: [
+        {
+          _id: 'custom1',
+          teamName: 'Custom Team',
+          reviewerCount: 2,
+          reviewerNames: ['Alice', 'Bob'],
+        },
+      ],
+    });
+
+    render(<PRGradingScreenContainer />);
+
+    expect(await screen.findByText(/Custom Team - 10\/4\/2026 - 2 reviewers/)).toBeInTheDocument();
+  });
+});
diff --git a/src/components/PRGradingScreen/PRGradingTest.jsx b/src/components/PRGradingScreen/PRGradingTest.jsx
index fd33f7d78e7..44bc714296c 100644
--- a/src/components/PRGradingScreen/PRGradingTest.jsx
+++ b/src/components/PRGradingScreen/PRGradingTest.jsx
@@ -50,7 +50,18 @@ const PRGradingTest = () => {
 
   const handleTeamSelect = teamId => {
     const team = allTeams.find(t => t.id === teamId);
-    history.push('/pr-grading-screen', { teamId, config: team });
+    const params = new URLSearchParams({ teamId });
+    if (team?.fromDB) {
+      const start = new Date();
+      start.setDate(start.getDate() - start.getDay());
+      const date = [
+        start.getFullYear(),
+        String(start.getMonth() + 1).padStart(2, '0'),
+        String(start.getDate()).padStart(2, '0'),
+      ].join('-');
+      params.set('weekStart', date);
+    }
+    history.push(`/pr-grading-screen?${params.toString()}`, { teamId, config: team });
   };
 
   const handleDeleteConfig = async (e, teamId) => {
diff --git a/src/components/PRGradingScreen/PRGradingView.jsx b/src/components/PRGradingScreen/PRGradingView.jsx
index 22a30e86789..a5ad8671bb2 100644
--- a/src/components/PRGradingScreen/PRGradingView.jsx
+++ b/src/components/PRGradingScreen/PRGradingView.jsx
@@ -21,6 +21,12 @@ const PRGradingView = ({
   onPromoteClick,
   activeInput,
   inputValue,
+  inputError,
+  loadError,
+  gradeError,
+  isLoadingSaved,
+  isSavingPR,
+  isSavingGrade,
   onInputValueChange,
   onAddNewClick,
   onInputSubmit,
@@ -55,16 +61,26 @@ const PRGradingView = ({
                 </div>
                 <Button
                   variant={isFinalized ? 'secondary' : 'outline-dark'}
-                  disabled={isFinalized}
+                  disabled={isFinalized || isSavingPR || isSavingGrade}
                   onClick={onFinalize}
                   className={`${styles['pr-grading-screen-done-button']} ${dm}`}
                 >
                   {isFinalized ? 'Finalized' : 'Done'}
                 </Button>
               </div>
+              {loadError && (
+                <p role="alert" className={`${styles['pr-grading-screen-error-message']} ${dm}`}>
+                  {loadError}
+                </p>
+              )}
             </Card.Header>
 
             <Card.Body className={dm}>
+              {gradeError && (
+                <p role="alert" className={`${styles['pr-grading-screen-error-message']} ${dm}`}>
+                  {gradeError}
+                </p>
+              )}
               {/* Search and Filter Bar */}
               <div className={`${styles['pr-grading-screen-search-bar']} ${dm}`}>
                 <input
@@ -198,6 +214,7 @@ const PRGradingView = ({
                                   <Button
                                     variant="success"
                                     size="sm"
+                                    disabled={isLoadingSaved || isSavingPR || Boolean(loadError)}
                                     className={styles['pr-grading-screen-add-btn']}
                                     onClick={() => onAddNewClick(reviewer.id)}
                                   >
@@ -211,20 +228,35 @@ const PRGradingView = ({
                                       <input
                                         type="text"
                                         value={inputValue}
+                                        disabled={isSavingPR}
                                         onChange={e => onInputValueChange(e.target.value)}
                                         className={styles['pr-grading-screen-pr-number-input']}
                                         placeholder="1070 or 1070 + 1256"
                                       />
+                                      {inputError && (
+                                        <span
+                                          role="alert"
+                                          className={`${styles['pr-grading-screen-error-message']} ${dm}`}
+                                        >
+                                          {inputError}
+                                        </span>
+                                      )}
                                     </div>
                                     <div className={styles['pr-grading-screen-input-buttons']}>
                                       <Button
                                         variant="primary"
                                         size="sm"
+                                        disabled={isSavingPR}
                                         onClick={() => onInputSubmit(reviewer.id)}
                                       >
-                                        Add
+                                        {isSavingPR ? 'Adding...' : 'Add'}
                                       </Button>
-                                      <Button variant="secondary" size="sm" onClick={onCancelInput}>
+                                      <Button
+                                        variant="secondary"
+                                        size="sm"
+                                        disabled={isSavingPR}
+                                        onClick={onCancelInput}
+                                      >
                                         Cancel
                                       </Button>
                                     </div>
@@ -236,7 +268,7 @@ const PRGradingView = ({
                             <InlinePRSummary
                               reviewer={reviewer}
                               onGradeChange={onGradeChange}
-                              isFinalized={isFinalized}
+                              isFinalized={isFinalized || isSavingGrade}
                               darkMode={darkMode}
                             />
                           </React.Fragment>
@@ -259,6 +291,7 @@ const PRGradingView = ({
               <h3>Grade PR for {gradingReviewer.reviewer}</h3>
               <button
                 className={`${styles['pr-grading-screen-modal-close']} ${dm}`}
+                disabled={isSavingGrade}
                 onClick={onCloseGradingModal}
               >
                 ×
@@ -285,7 +318,7 @@ const PRGradingView = ({
                         <td key={opt.value} className={styles['pr-grading-screen-checkbox-cell']}>
                           <input
                             type="checkbox"
-                            disabled={isFinalized}
+                            disabled={isFinalized || isSavingGrade}
                             checked={pr.grade === opt.value}
                             onChange={() => onGradeChange(gradingReviewer.id, pr.id, opt.value)}
                             className={styles['pr-grading-screen-grade-checkbox']}
@@ -301,6 +334,7 @@ const PRGradingView = ({
               <div className={`${styles['pr-grading-screen-modal-footer']} ${dm}`}>
                 <Button
                   variant="primary"
+                  disabled={isSavingGrade}
                   onClick={onCloseGradingModal}
                   className={`${styles['pr-grading-screen-done-btn']} ${dm}`}
                 >
@@ -413,6 +447,12 @@ PRGradingView.propTypes = {
   onPromoteClick: PropTypes.func.isRequired,
   activeInput: PropTypes.string,
   inputValue: PropTypes.string.isRequired,
+  inputError: PropTypes.string.isRequired,
+  loadError: PropTypes.string.isRequired,
+  gradeError: PropTypes.string.isRequired,
+  isLoadingSaved: PropTypes.bool.isRequired,
+  isSavingPR: PropTypes.bool.isRequired,
+  isSavingGrade: PropTypes.bool.isRequired,
   onInputValueChange: PropTypes.func.isRequired,
   onAddNewClick: PropTypes.func.isRequired,
   onInputSubmit: PropTypes.func.isRequired,
diff --git a/src/components/PRGradingScreen/__tests__/PRGradingScreen.test.jsx b/src/components/PRGradingScreen/__tests__/PRGradingScreen.test.jsx
index baa51aa6bf5..a226731c49f 100644
--- a/src/components/PRGradingScreen/__tests__/PRGradingScreen.test.jsx
+++ b/src/components/PRGradingScreen/__tests__/PRGradingScreen.test.jsx
@@ -1,8 +1,17 @@
-import { fireEvent, render, screen } from '@testing-library/react';
-import { describe, expect, it, vi } from 'vitest';
+import axios from 'axios';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 import PRGradingScreen from '../PRGradingScreen';
 import GRADE_OPTIONS from '../gradeOptions';
 
+vi.mock('axios');
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  axios.get.mockResolvedValue({ data: [] });
+  axios.post.mockResolvedValue({ data: { status: 'ok' } });
+});
+
 vi.mock('react-redux', async () => {
   const actual = await vi.importActual('react-redux');
   return { ...actual, useSelector: () => false };
@@ -24,8 +33,10 @@ const makeReviewers = () => [
   },
 ];
 
-const renderScreen = () =>
+const renderScreen = async () => {
   render(<PRGradingScreen teamData={teamData} reviewers={makeReviewers()} />);
+  await waitFor(() => expect(screen.getByRole('button', { name: '+ Add new' })).toBeEnabled());
+};
 
 // Both tables label their checkboxes `${prNumbers} ${label}`. Before the modal
 // opens only the inline summary is mounted, so there is exactly one match;
@@ -37,42 +48,45 @@ const checkboxes = label => screen.queryAllByLabelText(`1070 ${label}`);
 const openModal = () => fireEvent.click(screen.getByRole('button', { name: '1070' }));
 
 describe('PRGradingScreen grade sync between inline summary and modal', () => {
-  it.each(GRADE_OPTIONS.map(o => o.label))('reflects an inline "%s" grade in the modal', label => {
-    renderScreen();
-
-    // Only the inline summary is mounted before the modal opens.
-    const [inline] = checkboxes(label);
-    fireEvent.click(inline);
-    expect(inline).toBeChecked();
-
-    openModal();
-
-    // Both tables are mounted now; the second match is the modal's.
-    const all = checkboxes(label);
-    expect(all).toHaveLength(2);
-    expect(all[1]).toBeChecked();
-  });
+  it.each(GRADE_OPTIONS.map(o => o.label))(
+    'reflects an inline "%s" grade in the modal',
+    async label => {
+      await renderScreen();
+
+      // Only the inline summary is mounted before the modal opens.
+      const [inline] = checkboxes(label);
+      fireEvent.click(inline);
+      await waitFor(() => expect(inline).toBeChecked());
+
+      openModal();
+
+      // Both tables are mounted now; the second match is the modal's.
+      const all = checkboxes(label);
+      expect(all).toHaveLength(2);
+      expect(all[1]).toBeChecked();
+    },
+  );
 
-  it('keeps a single grade selected when switching options inline', () => {
-    renderScreen();
+  it('keeps a single grade selected when switching options inline', async () => {
+    await renderScreen();
 
     fireEvent.click(checkboxes('Cannot find image')[0]);
-    expect(checkboxes('Cannot find image')[0]).toBeChecked();
+    await waitFor(() => expect(checkboxes('Cannot find image')[0]).toBeChecked());
     expect(checkboxes('Okay')[0]).not.toBeChecked();
 
     fireEvent.click(checkboxes('Exceptional')[0]);
-    expect(checkboxes('Exceptional')[0]).toBeChecked();
+    await waitFor(() => expect(checkboxes('Exceptional')[0]).toBeChecked());
     expect(checkboxes('Cannot find image')[0]).not.toBeChecked();
   });
 
-  it('propagates a modal grade back to the inline summary', () => {
-    renderScreen();
+  it('propagates a modal grade back to the inline summary', async () => {
+    await renderScreen();
     openModal();
 
     const [inline, modal] = checkboxes('Cannot find image');
     fireEvent.click(modal);
 
-    expect(modal).toBeChecked();
+    await waitFor(() => expect(modal).toBeChecked());
     expect(inline).toBeChecked();
   });
 });
diff --git a/src/components/PRGradingScreen/index.jsx b/src/components/PRGradingScreen/index.jsx
index 37aed6ec1eb..f3eaef45d50 100644
--- a/src/components/PRGradingScreen/index.jsx
+++ b/src/components/PRGradingScreen/index.jsx
@@ -1,5 +1,8 @@
+import axios from 'axios';
+import { useEffect, useState } from 'react';
 import { useLocation } from 'react-router-dom';
 import { v4 as uuidv4 } from 'uuid';
+import { ENDPOINTS } from '../../utils/URL';
 import { getDataByTeamId } from './mockData';
 import PRGradingScreen from './PRGradingScreen';
 
@@ -7,8 +10,43 @@ const STATIC_IDS = ['team1', 'team2', 'team3'];
 
 const PRGradingScreenContainer = () => {
   const location = useLocation();
-  const teamId = location.state?.teamId || 'team1';
-  const config = location.state?.config || null;
+  const params = new URLSearchParams(location.search);
+  const teamId = params.get('teamId') || location.state?.teamId || 'team1';
+  const [savedConfig, setSavedConfig] = useState(null);
+  const [configError, setConfigError] = useState('');
+  const locationConfig = location.state?.teamId === teamId ? location.state?.config : null;
+  const config = locationConfig || (savedConfig?.id === teamId ? savedConfig : null);
+
+  useEffect(() => {
+    if (STATIC_IDS.includes(teamId) || locationConfig) return undefined;
+    let active = true;
+    axios
+      .get(ENDPOINTS.PR_GRADING_CONFIG)
+      .then(response => {
+        if (!active) return;
+        const match = response.data.find(item => item._id === teamId);
+        if (match) {
+          setSavedConfig({
+            id: match._id,
+            name: match.teamName,
+            reviewerCount: match.reviewerCount,
+            reviewerNames: match.reviewerNames,
+          });
+        } else {
+          setConfigError('Team configuration not found.');
+        }
+      })
+      .catch(() => {
+        if (active) setConfigError('Could not load the team configuration.');
+      });
+    return () => {
+      active = false;
+    };
+  }, [teamId, locationConfig]);
+
+  if (!STATIC_IDS.includes(teamId) && !config) {
+    return <div>{configError || 'Loading team configuration...'}</div>;
+  }
 
   if (!STATIC_IDS.includes(teamId) && config) {
     const reviewers = Array.from({ length: config.reviewerCount }, (_, i) => ({
@@ -19,11 +57,20 @@ const PRGradingScreenContainer = () => {
       gradedPrs: [],
     }));
 
+    const weekStart = params.get('weekStart');
+    if (weekStart && !/^\d{4}-\d{2}-\d{2}$/.test(weekStart)) {
+      return <div>Invalid week start date.</div>;
+    }
+    const start = weekStart ? new Date(`${weekStart}T12:00:00`) : new Date();
+    if (Number.isNaN(start.getTime())) return <div>Invalid week start date.</div>;
+    if (!weekStart) start.setDate(start.getDate() - start.getDay());
+    const end = new Date(start);
+    end.setDate(start.getDate() + 7);
     const teamData = {
       teamName: config.name,
       dateRange: {
-        start: new Date().toLocaleDateString(),
-        end: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toLocaleDateString(),
+        start: start.toLocaleDateString('en-US'),
+        end: end.toLocaleDateString('en-US'),
       },
     };
 
diff --git a/src/components/PRGradingScreen/prGradingPersistence.js b/src/components/PRGradingScreen/prGradingPersistence.js
new file mode 100644
index 00000000000..8342bb7b345
--- /dev/null
+++ b/src/components/PRGradingScreen/prGradingPersistence.js
@@ -0,0 +1,85 @@
+import axios from 'axios';
+import { ENDPOINTS } from '../../utils/URL';
+
+const getPRNumbers = value => value.split('+').map(number => number.trim());
+const toDisplayGrade = grade => (grade === 'No Correct Image' ? 'Cannot find image' : grade);
+
+const getGradingKey = teamData => {
+  const [month, day, year] = teamData.dateRange.start.split('/').map(Number);
+  const date = `${year}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+  return { teamKey: `pr-grading-screen:${teamData.teamName}`, date };
+};
+
+export const loadSavedGradings = async teamData => {
+  const { teamKey, date } = getGradingKey(teamData);
+  const response = await axios.get(ENDPOINTS.WEEKLY_GRADING, {
+    params: { team: teamKey, date, weekStart: date },
+  });
+  return response.data;
+};
+
+export const saveAddedPR = (teamData, reviewer, prNumbers) => {
+  const { teamKey, date } = getGradingKey(teamData);
+  return axios.post(ENDPOINTS.WEEKLY_GRADING_SAVE, {
+    teamCode: teamKey,
+    teamName: teamKey,
+    date,
+    gradings: [
+      {
+        reviewer: reviewer.reviewer,
+        prsNeeded: reviewer.prsNeeded,
+        prsReviewed: reviewer.gradedPrs.length + 1,
+        gradedPrs: [{ prNumbers, grade: 'Okay' }],
+      },
+    ],
+  });
+};
+
+export const saveGradeChange = (teamData, reviewer, prNumbers, grade) => {
+  const { teamKey, date } = getGradingKey(teamData);
+  return axios.post(ENDPOINTS.WEEKLY_GRADING_SAVE, {
+    teamCode: teamKey,
+    teamName: teamKey,
+    date,
+    gradings: [
+      {
+        reviewer: reviewer.reviewer,
+        prsNeeded: reviewer.prsNeeded,
+        prsReviewed: reviewer.gradedPrs.length,
+        gradedPrs: [{ prNumbers, grade }],
+      },
+    ],
+  });
+};
+
+export const mergeSavedGradings = (reviewers, savedGradings) => {
+  const savedByReviewer = new Map(savedGradings.map(grading => [grading.reviewer, grading]));
+
+  return reviewers.map(reviewer => {
+    const savedPrs = savedByReviewer.get(reviewer.reviewer)?.gradedPrs || [];
+    const savedGrades = new Map(
+      savedPrs.map(pr => [getPRNumbers(pr.prNumbers).join('+'), toDisplayGrade(pr.grade)]),
+    );
+    const seen = new Set(reviewer.gradedPrs.flatMap(pr => getPRNumbers(pr.prNumbers)));
+    const additions = savedPrs
+      .filter(pr => {
+        const numbers = getPRNumbers(pr.prNumbers);
+        if (numbers.some(number => seen.has(number))) return false;
+        numbers.forEach(number => seen.add(number));
+        return true;
+      })
+      .map(pr => ({
+        ...pr,
+        id: String(pr._id || pr.id || pr.prNumbers),
+        grade: toDisplayGrade(pr.grade),
+      }));
+    const gradedPrs = [
+      ...reviewer.gradedPrs.map(pr => ({
+        ...pr,
+        grade: savedGrades.get(getPRNumbers(pr.prNumbers).join('+')) || pr.grade,
+      })),
+      ...additions,
+    ];
+    return { ...reviewer, gradedPrs, prsReviewed: gradedPrs.length };
+  });
+};
diff --git a/src/components/PRGradingScreen/prGradingPersistence.test.js b/src/components/PRGradingScreen/prGradingPersistence.test.js
new file mode 100644
index 00000000000..f5e59393289
--- /dev/null
+++ b/src/components/PRGradingScreen/prGradingPersistence.test.js
@@ -0,0 +1,154 @@
+import axios from 'axios';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ENDPOINTS } from '../../utils/URL';
+import {
+  loadSavedGradings,
+  mergeSavedGradings,
+  saveAddedPR,
+  saveGradeChange,
+} from './prGradingPersistence';
+
+vi.mock('axios');
+
+const teamData = {
+  teamName: '91NePRT',
+  dateRange: { start: '5/18/2025', end: '5/25/2025' },
+};
+
+describe('PR grading persistence', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('loads saved PRs for the displayed team and week', async () => {
+    axios.get.mockResolvedValue({ data: [{ reviewer: 'Alice', gradedPrs: [] }] });
+
+    await expect(loadSavedGradings(teamData)).resolves.toHaveLength(1);
+    expect(axios.get).toHaveBeenCalledWith(ENDPOINTS.WEEKLY_GRADING, {
+      params: {
+        team: 'pr-grading-screen:91NePRT',
+        date: '2025-05-18',
+        weekStart: '2025-05-18',
+      },
+    });
+  });
+
+  it('saves only the newly added PR for one reviewer', async () => {
+    const reviewer = {
+      reviewer: 'Alice',
+      prsNeeded: 3,
+      gradedPrs: [{ prNumbers: '1234', grade: 'Okay' }],
+    };
+
+    await saveAddedPR(teamData, reviewer, '5678 + 9999');
+
+    expect(axios.post).toHaveBeenCalledWith(ENDPOINTS.WEEKLY_GRADING_SAVE, {
+      teamCode: 'pr-grading-screen:91NePRT',
+      teamName: 'pr-grading-screen:91NePRT',
+      date: '2025-05-18',
+      gradings: [
+        {
+          reviewer: 'Alice',
+          prsNeeded: 3,
+          prsReviewed: 2,
+          gradedPrs: [{ prNumbers: '5678 + 9999', grade: 'Okay' }],
+        },
+      ],
+    });
+  });
+
+  it('saves only the changed grade without increasing the reviewed count', async () => {
+    const reviewer = {
+      reviewer: 'Alice',
+      prsNeeded: 3,
+      gradedPrs: [{ prNumbers: '1234', grade: 'Okay' }],
+    };
+
+    await saveGradeChange(teamData, reviewer, '1234', 'Exceptional');
+
+    expect(axios.post).toHaveBeenCalledWith(ENDPOINTS.WEEKLY_GRADING_SAVE, {
+      teamCode: 'pr-grading-screen:91NePRT',
+      teamName: 'pr-grading-screen:91NePRT',
+      date: '2025-05-18',
+      gradings: [
+        {
+          reviewer: 'Alice',
+          prsNeeded: 3,
+          prsReviewed: 1,
+          gradedPrs: [{ prNumbers: '1234', grade: 'Exceptional' }],
+        },
+      ],
+    });
+  });
+
+  it('merges saved PRs with built-in entries without duplicating them', () => {
+    const reviewers = [
+      {
+        id: '1',
+        reviewer: 'Alice',
+        prsNeeded: 3,
+        gradedPrs: [{ id: 'pr1', prNumbers: '1234', grade: 'Okay' }],
+      },
+    ];
+    const saved = [
+      {
+        reviewer: 'Alice',
+        gradedPrs: [
+          { _id: 'saved1', prNumbers: '1234', grade: 'Okay' },
+          { _id: 'saved2', prNumbers: '5678 + 9999', grade: 'Okay' },
+        ],
+      },
+    ];
+
+    expect(mergeSavedGradings(reviewers, saved)[0]).toMatchObject({
+      prsReviewed: 2,
+      gradedPrs: [
+        { id: 'pr1', prNumbers: '1234' },
+        { id: 'saved2', prNumbers: '5678 + 9999' },
+      ],
+    });
+  });
+
+  it('uses the saved grade for a built-in PR after reloading', () => {
+    const reviewers = [
+      {
+        id: '1',
+        reviewer: 'Alice',
+        gradedPrs: [{ id: 'pr1', prNumbers: '1234 + 5678', grade: 'Okay' }],
+      },
+    ];
+    const saved = [
+      {
+        reviewer: 'Alice',
+        gradedPrs: [{ prNumbers: '1234+5678', grade: 'Exceptional' }],
+      },
+    ];
+
+    expect(mergeSavedGradings(reviewers, saved)[0]).toMatchObject({
+      prsReviewed: 1,
+      gradedPrs: [{ id: 'pr1', prNumbers: '1234 + 5678', grade: 'Exceptional' }],
+    });
+  });
+
+  it('displays the backend image grade for built-in and newly saved PRs', () => {
+    const reviewers = [
+      {
+        id: '1',
+        reviewer: 'Alice',
+        gradedPrs: [{ id: 'pr1', prNumbers: '1234', grade: 'Okay' }],
+      },
+    ];
+    const saved = [
+      {
+        reviewer: 'Alice',
+        gradedPrs: [
+          { prNumbers: '1234', grade: 'No Correct Image' },
+          { prNumbers: '5678', grade: 'No Correct Image' },
+        ],
+      },
+    ];
+
+    expect(mergeSavedGradings(reviewers, saved)[0].gradedPrs).toMatchObject([
+      { prNumbers: '1234', grade: 'Cannot find image' },
+      { prNumbers: '5678', grade: 'Cannot find image' },
+    ]);
+  });
+});