diff --git a/firebase/LEVANTE/admin/firestore.rules b/firebase/LEVANTE/admin/firestore.rules
index 2e10245ce..f74e9b0e0 100644
--- a/firebase/LEVANTE/admin/firestore.rules
+++ b/firebase/LEVANTE/admin/firestore.rules
@@ -67,12 +67,13 @@ service cloud.firestore {
         allow read, write: if request.auth.uid == uid;
       }
 
-      function isUserAdmin() {
-        let districts = resource.data.get(['districts', 'current'], []);
-        let schools = resource.data.get(['schools', 'current'], []);
-        let classes = resource.data.get(['classes', 'current'], []);
-        let groups = resource.data.get(['groups', 'current'], []);
-        let families = resource.data.get(['families', 'current'], []);
+      function isUserAdmin(requireCurrent) {
+        let orgStatus = requireCurrent ? 'current' : 'all';
+        let districts = resource.data.get(['districts', orgStatus], []);
+        let schools = resource.data.get(['schools', orgStatus], []);
+        let classes = resource.data.get(['classes', orgStatus], []);
+        let groups = resource.data.get(['groups', orgStatus], []);
+        let families = resource.data.get(['families', orgStatus], []);
         let adminOrgs = get(/databases/$(database)/documents/userClaims/$(request.auth.uid)).data.get('claims', {}).get('adminOrgs', {});
         return districts.hasAny(adminOrgs.get('districts', ['..']))
         || schools.hasAny(adminOrgs.get('schools', ['..']))
@@ -82,7 +83,7 @@ service cloud.firestore {
       }
 
       function canReadExistingUser() {
-        return myData() || isUserAdmin();
+        return myData() || isUserAdmin(false) || isUserAdmin(true);
       }
 
       allow read: if canReadExistingUser();
diff --git a/firebase/LEVANTE/assessment/firestore.rules b/firebase/LEVANTE/assessment/firestore.rules
index 067f11b6d..2f6848964 100644
--- a/firebase/LEVANTE/assessment/firestore.rules
+++ b/firebase/LEVANTE/assessment/firestore.rules
@@ -55,12 +55,13 @@ service cloud.firestore {
         return uid == roarUid();
       }
 
-      function isUserAdmin() {
-        let districts = resource.data.get(['districts', 'current'], []);
-        let schools = resource.data.get(['schools', 'current'], []);
-        let classes = resource.data.get(['classes', 'current'], []);
-        let groups = resource.data.get(['groups', 'current'], []);
-        let families = resource.data.get(['families', 'current'], []);
+      function isUserAdmin(requireCurrent) {
+        let orgStatus = requireCurrent ? 'current' : 'all';
+        let districts = resource.data.get(['districts', orgStatus], []);
+        let schools = resource.data.get(['schools', orgStatus], []);
+        let classes = resource.data.get(['classes', orgStatus], []);
+        let groups = resource.data.get(['groups', orgStatus], []);
+        let families = resource.data.get(['families', orgStatus], []);
         let adminOrgs = get(/databases/$(database)/documents/userClaims/$(request.auth.uid)).data.get('claims', {}).get('adminOrgs', {});
         return districts.hasAny(adminOrgs.get('districts', ['..']))
         || schools.hasAny(adminOrgs.get('schools', ['..']))
@@ -70,7 +71,7 @@ service cloud.firestore {
       }
 
       function canReadExistingUser() {
-        return myData() || isUserAdmin();
+        return myData() || isUserAdmin(false) || isUserAdmin(true);
       }
 
       allow read: if canReadExistingUser();
diff --git a/firebase/admin/firestore.indexes.json b/firebase/admin/firestore.indexes.json
index 289ecbee9..199db5dd3 100644
--- a/firebase/admin/firestore.indexes.json
+++ b/firebase/admin/firestore.indexes.json
@@ -2,11 +2,25 @@
   "indexes": [
     {
       "collectionGroup": "administrations",
-      "queryScope": "COLLECTION_GROUP",
+      "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "testData",
+          "fieldPath": "districts",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "dateClosed",
           "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "administrations",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "readOrgs.classes",
+          "arrayConfig": "CONTAINS"
         },
         {
           "fieldPath": "name",
@@ -19,7 +33,7 @@
       "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "readOrgs.classes",
+          "fieldPath": "readOrgs.districts",
           "arrayConfig": "CONTAINS"
         },
         {
@@ -36,6 +50,10 @@
           "fieldPath": "readOrgs.districts",
           "arrayConfig": "CONTAINS"
         },
+        {
+          "fieldPath": "testData",
+          "order": "ASCENDING"
+        },
         {
           "fieldPath": "name",
           "order": "ASCENDING"
@@ -70,6 +88,24 @@
         }
       ]
     },
+    {
+      "collectionGroup": "administrations",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "readOrgs.groups",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "testData",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "name",
+          "order": "ASCENDING"
+        }
+      ]
+    },
     {
       "collectionGroup": "administrations",
       "queryScope": "COLLECTION",
@@ -84,6 +120,80 @@
         }
       ]
     },
+    {
+      "collectionGroup": "administrations",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "schools",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "dateClosed",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "administrations",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "testData",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "name",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "assignedOrgs",
+      "queryScope": "COLLECTION_GROUP",
+      "fields": [
+        {
+          "fieldPath": "orgId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "dateClosed",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "assignedOrgs",
+      "queryScope": "COLLECTION_GROUP",
+      "fields": [
+        {
+          "fieldPath": "orgId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "testData",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "assignedOrgs",
+      "queryScope": "COLLECTION_GROUP",
+      "fields": [
+        {
+          "fieldPath": "orgId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "testData",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "dateClosed",
+          "order": "ASCENDING"
+        }
+      ]
+    },
     {
       "collectionGroup": "assignments",
       "queryScope": "COLLECTION_GROUP",
@@ -2998,6 +3108,10 @@
       "collectionGroup": "classes",
       "queryScope": "COLLECTION",
       "fields": [
+        {
+          "fieldPath": "archived",
+          "order": "ASCENDING"
+        },
         {
           "fieldPath": "schoolId",
           "order": "ASCENDING"
@@ -3012,6 +3126,10 @@
       "collectionGroup": "classes",
       "queryScope": "COLLECTION",
       "fields": [
+        {
+          "fieldPath": "archived",
+          "order": "ASCENDING"
+        },
         {
           "fieldPath": "schoolId",
           "order": "ASCENDING"
@@ -3023,7 +3141,7 @@
       ]
     },
     {
-      "collectionGroup": "schools",
+      "collectionGroup": "classes",
       "queryScope": "COLLECTION",
       "fields": [
         {
@@ -3031,59 +3149,59 @@
           "order": "ASCENDING"
         },
         {
-          "fieldPath": "abbreviation",
+          "fieldPath": "lastRoarSync",
           "order": "ASCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "schools",
+      "collectionGroup": "classes",
       "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "districtId",
+          "fieldPath": "schoolId",
           "order": "ASCENDING"
         },
         {
-          "fieldPath": "abbreviation",
-          "order": "DESCENDING"
+          "fieldPath": "name",
+          "order": "ASCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "schools",
+      "collectionGroup": "classes",
       "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "districtId",
+          "fieldPath": "schoolId",
           "order": "ASCENDING"
         },
         {
-          "fieldPath": "address",
-          "order": "ASCENDING"
+          "fieldPath": "name",
+          "order": "DESCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "schools",
+      "collectionGroup": "districts",
       "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "districtId",
+          "fieldPath": "archived",
           "order": "ASCENDING"
         },
         {
-          "fieldPath": "address",
-          "order": "DESCENDING"
+          "fieldPath": "name",
+          "order": "ASCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "schools",
+      "collectionGroup": "families",
       "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "districtId",
+          "fieldPath": "archived",
           "order": "ASCENDING"
         },
         {
@@ -3093,187 +3211,623 @@
       ]
     },
     {
-      "collectionGroup": "schools",
+      "collectionGroup": "groups",
       "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "districtId",
+          "fieldPath": "archived",
           "order": "ASCENDING"
         },
         {
           "fieldPath": "name",
-          "order": "DESCENDING"
+          "order": "ASCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "users",
-      "queryScope": "COLLECTION",
+      "collectionGroup": "readOrgs",
+      "queryScope": "COLLECTION_GROUP",
       "fields": [
         {
-          "fieldPath": "assigningOrgs.districts",
-          "arrayConfig": "CONTAINS"
-        },
-        {
-          "fieldPath": "schoolName",
+          "fieldPath": "orgId",
           "order": "ASCENDING"
         },
         {
-          "fieldPath": "assignmentsAssigned.wTWJITpjKthvDJ9fSTNW",
+          "fieldPath": "dateClosed",
           "order": "ASCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "users",
-      "queryScope": "COLLECTION",
+      "collectionGroup": "readOrgs",
+      "queryScope": "COLLECTION_GROUP",
       "fields": [
         {
-          "fieldPath": "assigningOrgs.districts",
-          "arrayConfig": "CONTAINS"
-        },
-        {
-          "fieldPath": "studentData.grade",
+          "fieldPath": "orgId",
           "order": "ASCENDING"
         },
         {
-          "fieldPath": "assignmentsAssigned.wTWJITpjKthvDJ9fSTNW",
+          "fieldPath": "testData",
           "order": "ASCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "users",
-      "queryScope": "COLLECTION",
+      "collectionGroup": "readOrgs",
+      "queryScope": "COLLECTION_GROUP",
       "fields": [
         {
-          "fieldPath": "classes.current",
-          "arrayConfig": "CONTAINS"
+          "fieldPath": "orgId",
+          "order": "ASCENDING"
         },
         {
-          "fieldPath": "name",
+          "fieldPath": "testData",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "dateClosed",
           "order": "ASCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "users",
+      "collectionGroup": "schools",
       "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "classes.current",
-          "arrayConfig": "CONTAINS"
+          "fieldPath": "archived",
+          "order": "ASCENDING"
         },
         {
-          "fieldPath": "name.first",
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "abbreviation",
           "order": "ASCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "users",
+      "collectionGroup": "schools",
       "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "classes.current",
-          "arrayConfig": "CONTAINS"
+          "fieldPath": "archived",
+          "order": "ASCENDING"
         },
         {
-          "fieldPath": "name.first",
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "abbreviation",
           "order": "DESCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "users",
+      "collectionGroup": "schools",
       "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "classes.current",
-          "arrayConfig": "CONTAINS"
+          "fieldPath": "archived",
+          "order": "ASCENDING"
         },
         {
-          "fieldPath": "name.last",
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "address",
           "order": "ASCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "users",
+      "collectionGroup": "schools",
       "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "classes.current",
-          "arrayConfig": "CONTAINS"
+          "fieldPath": "archived",
+          "order": "ASCENDING"
         },
         {
-          "fieldPath": "name.last",
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "address",
           "order": "DESCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "users",
+      "collectionGroup": "schools",
       "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "classes.current",
-          "arrayConfig": "CONTAINS"
+          "fieldPath": "archived",
+          "order": "ASCENDING"
         },
         {
-          "fieldPath": "studentData.dob",
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "name",
           "order": "ASCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "users",
+      "collectionGroup": "schools",
       "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "classes.current",
-          "arrayConfig": "CONTAINS"
+          "fieldPath": "archived",
+          "order": "ASCENDING"
         },
         {
-          "fieldPath": "studentData.dob",
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "name",
           "order": "DESCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "users",
+      "collectionGroup": "schools",
       "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "classes.current",
-          "arrayConfig": "CONTAINS"
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
         },
         {
-          "fieldPath": "studentData.gender",
+          "fieldPath": "abbreviation",
           "order": "ASCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "users",
+      "collectionGroup": "schools",
       "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "classes.current",
-          "arrayConfig": "CONTAINS"
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
         },
         {
-          "fieldPath": "studentData.gender",
+          "fieldPath": "abbreviation",
           "order": "DESCENDING"
         }
       ]
     },
     {
-      "collectionGroup": "users",
+      "collectionGroup": "schools",
       "queryScope": "COLLECTION",
       "fields": [
         {
-          "fieldPath": "classes.current",
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "address",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "schools",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "address",
+          "order": "DESCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "schools",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "lastRoarSync",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "schools",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "archived",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "name",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "schools",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "archived",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "name",
+          "order": "DESCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "schools",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "abbreviation",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "schools",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "abbreviation",
+          "order": "DESCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "schools",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "address",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "schools",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "address",
+          "order": "DESCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "schools",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "lastRoarSync",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "schools",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "archived",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "name",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "schools",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "archived",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "districtId",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "name",
+          "order": "DESCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION_GROUP",
+      "fields": [
+        {
+          "fieldPath": "classes.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "name",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION_GROUP",
+      "fields": [
+        {
+          "fieldPath": "districts.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "name",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION_GROUP",
+      "fields": [
+        {
+          "fieldPath": "families.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "name",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION_GROUP",
+      "fields": [
+        {
+          "fieldPath": "groups.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "name",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION_GROUP",
+      "fields": [
+        {
+          "fieldPath": "schools.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "name",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "assigningOrgs.districts",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "schoolName",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "assignmentsAssigned.wTWJITpjKthvDJ9fSTNW",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "assigningOrgs.districts",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "studentData.grade",
+          "order": "ASCENDING"
+        },
+        {
+          "fieldPath": "assignmentsAssigned.wTWJITpjKthvDJ9fSTNW",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "classes.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "name",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "classes.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "name.first",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "classes.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "name.first",
+          "order": "DESCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "classes.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "name.last",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "classes.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "name.last",
+          "order": "DESCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "classes.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "studentData.dob",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "classes.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "studentData.dob",
+          "order": "DESCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "classes.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "studentData.gender",
+          "order": "ASCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "classes.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "studentData.gender",
+          "order": "DESCENDING"
+        }
+      ]
+    },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "classes.current",
           "arrayConfig": "CONTAINS"
         },
         {
@@ -3352,6 +3906,20 @@
         }
       ]
     },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "districts.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "archived",
+          "order": "ASCENDING"
+        }
+      ]
+    },
     {
       "collectionGroup": "users",
       "queryScope": "COLLECTION",
@@ -3366,6 +3934,20 @@
         }
       ]
     },
+    {
+      "collectionGroup": "users",
+      "queryScope": "COLLECTION",
+      "fields": [
+        {
+          "fieldPath": "districts.current",
+          "arrayConfig": "CONTAINS"
+        },
+        {
+          "fieldPath": "lastRoarSync",
+          "order": "ASCENDING"
+        }
+      ]
+    },
     {
       "collectionGroup": "users",
       "queryScope": "COLLECTION",
@@ -4218,46 +4800,88 @@
       "collectionGroup": "administrations",
       "fieldPath": "classes",
       "ttl": false,
+      "indexes": []
+    },
+    {
+      "collectionGroup": "administrations",
+      "fieldPath": "createdBy",
+      "ttl": false,
       "indexes": [
         {
-          "arrayConfig": "CONTAINS",
+          "order": "ASCENDING",
           "queryScope": "COLLECTION"
         }
       ]
     },
     {
       "collectionGroup": "administrations",
-      "fieldPath": "districts",
+      "fieldPath": "dateClosed",
       "ttl": false,
       "indexes": [
         {
-          "arrayConfig": "CONTAINS",
+          "order": "ASCENDING",
+          "queryScope": "COLLECTION"
+        },
+        {
+          "order": "DESCENDING",
           "queryScope": "COLLECTION"
         }
       ]
     },
     {
       "collectionGroup": "administrations",
-      "fieldPath": "families",
+      "fieldPath": "dateCreated",
       "ttl": false,
       "indexes": [
         {
-          "arrayConfig": "CONTAINS",
+          "order": "ASCENDING",
+          "queryScope": "COLLECTION"
+        },
+        {
+          "order": "DESCENDING",
           "queryScope": "COLLECTION"
         }
       ]
     },
     {
       "collectionGroup": "administrations",
-      "fieldPath": "groups",
+      "fieldPath": "dateOpened",
       "ttl": false,
       "indexes": [
         {
-          "arrayConfig": "CONTAINS",
+          "order": "ASCENDING",
+          "queryScope": "COLLECTION"
+        },
+        {
+          "order": "DESCENDING",
           "queryScope": "COLLECTION"
         }
       ]
     },
+    {
+      "collectionGroup": "administrations",
+      "fieldPath": "districts",
+      "ttl": false,
+      "indexes": []
+    },
+    {
+      "collectionGroup": "administrations",
+      "fieldPath": "families",
+      "ttl": false,
+      "indexes": []
+    },
+    {
+      "collectionGroup": "administrations",
+      "fieldPath": "groups",
+      "ttl": false,
+      "indexes": []
+    },
+    {
+      "collectionGroup": "administrations",
+      "fieldPath": "minimalOrgs",
+      "ttl": false,
+      "indexes": []
+    },
     {
       "collectionGroup": "administrations",
       "fieldPath": "name",
@@ -4274,10 +4898,6 @@
         {
           "arrayConfig": "CONTAINS",
           "queryScope": "COLLECTION"
-        },
-        {
-          "order": "ASCENDING",
-          "queryScope": "COLLECTION_GROUP"
         }
       ]
     },
@@ -4346,16 +4966,40 @@
       "collectionGroup": "administrations",
       "fieldPath": "schools",
       "ttl": false,
+      "indexes": []
+    },
+    {
+      "collectionGroup": "administrations",
+      "fieldPath": "sequential",
+      "ttl": false,
+      "indexes": []
+    },
+    {
+      "collectionGroup": "administrations",
+      "fieldPath": "testData",
+      "ttl": false,
       "indexes": [
+        {
+          "order": "ASCENDING",
+          "queryScope": "COLLECTION"
+        },
+        {
+          "order": "DESCENDING",
+          "queryScope": "COLLECTION"
+        },
         {
           "arrayConfig": "CONTAINS",
           "queryScope": "COLLECTION"
+        },
+        {
+          "order": "ASCENDING",
+          "queryScope": "COLLECTION_GROUP"
         }
       ]
     },
     {
-      "collectionGroup": "administrations",
-      "fieldPath": "testData",
+      "collectionGroup": "assignedOrgs",
+      "fieldPath": "orgId",
       "ttl": false,
       "indexes": [
         {
@@ -4376,6 +5020,25 @@
         }
       ]
     },
+    {
+      "collectionGroup": "assignments",
+      "fieldPath": "assessments",
+      "ttl": false,
+      "indexes": [
+        {
+          "order": "ASCENDING",
+          "queryScope": "COLLECTION"
+        },
+        {
+          "order": "DESCENDING",
+          "queryScope": "COLLECTION"
+        },
+        {
+          "arrayConfig": "CONTAINS",
+          "queryScope": "COLLECTION"
+        }
+      ]
+    },
     {
       "collectionGroup": "assignments",
       "fieldPath": "assigningOrgs",
@@ -4432,6 +5095,29 @@
       "ttl": false,
       "indexes": []
     },
+    {
+      "collectionGroup": "readOrgs",
+      "fieldPath": "orgId",
+      "ttl": false,
+      "indexes": [
+        {
+          "order": "ASCENDING",
+          "queryScope": "COLLECTION"
+        },
+        {
+          "order": "DESCENDING",
+          "queryScope": "COLLECTION"
+        },
+        {
+          "arrayConfig": "CONTAINS",
+          "queryScope": "COLLECTION"
+        },
+        {
+          "order": "ASCENDING",
+          "queryScope": "COLLECTION_GROUP"
+        }
+      ]
+    },
     {
       "collectionGroup": "status",
       "fieldPath": "completion",
diff --git a/firebase/admin/firestore.rules b/firebase/admin/firestore.rules
index 284b25c27..2a36db6a1 100644
--- a/firebase/admin/firestore.rules
+++ b/firebase/admin/firestore.rules
@@ -74,12 +74,13 @@ service cloud.firestore {
         return uid == roarUid();
       }
 
-      function isUserAdmin() {
-        let districts = resource.data.get(['districts', 'current'], []);
-        let schools = resource.data.get(['schools', 'current'], []);
-        let classes = resource.data.get(['classes', 'current'], []);
-        let groups = resource.data.get(['groups', 'current'], []);
-        let families = resource.data.get(['families', 'current'], []);
+      function isUserAdmin(requireCurrent) {
+        let orgStatus = requireCurrent ? 'current' : 'all';
+        let districts = resource.data.get(['districts', orgStatus], []);
+        let schools = resource.data.get(['schools', orgStatus], []);
+        let classes = resource.data.get(['classes', orgStatus], []);
+        let groups = resource.data.get(['groups', orgStatus], []);
+        let families = resource.data.get(['families', orgStatus], []);
         let adminOrgs = get(/databases/$(database)/documents/userClaims/$(request.auth.uid)).data.get('claims', {}).get('adminOrgs', {});
         return districts.hasAny(adminOrgs.get('districts', ['..']))
         || schools.hasAny(adminOrgs.get('schools', ['..']))
@@ -89,7 +90,7 @@ service cloud.firestore {
       }
 
       function canReadExistingUser() {
-        return myData() || isUserAdmin();
+        return myData() || isUserAdmin(false) || isUserAdmin(true);
       }
 
       allow read: if canReadExistingUser();
diff --git a/firebase/assessment/firestore.rules b/firebase/assessment/firestore.rules
index ea0b52863..70a609805 100644
--- a/firebase/assessment/firestore.rules
+++ b/firebase/assessment/firestore.rules
@@ -57,12 +57,13 @@ service cloud.firestore {
         return uid == roarUid();
       }
 
-      function isUserAdmin() {
-        let districts = resource.data.get(['districts', 'current'], []);
-        let schools = resource.data.get(['schools', 'current'], []);
-        let classes = resource.data.get(['classes', 'current'], []);
-        let groups = resource.data.get(['groups', 'current'], []);
-        let families = resource.data.get(['families', 'current'], []);
+      function isUserAdmin(requireCurrent) {
+        let orgStatus = requireCurrent ? 'current' : 'all';
+        let districts = resource.data.get(['districts', orgStatus], []);
+        let schools = resource.data.get(['schools', orgStatus], []);
+        let classes = resource.data.get(['classes', orgStatus], []);
+        let groups = resource.data.get(['groups', orgStatus], []);
+        let families = resource.data.get(['families', orgStatus], []);
         let adminOrgs = get(/databases/$(database)/documents/userClaims/$(request.auth.uid)).data.get('claims', {}).get('adminOrgs', {});
         return districts.hasAny(adminOrgs.get('districts', ['..']))
         || schools.hasAny(adminOrgs.get('schools', ['..']))
@@ -72,7 +73,7 @@ service cloud.firestore {
       }
 
       function canReadExistingUser() {
-        return myData() || isUserAdmin();
+        return myData() || isUserAdmin(false) || isUserAdmin(true);
       }
 
       allow read: if canReadExistingUser();
diff --git a/package-lock.json b/package-lock.json
index 59ce71c39..057e6f2f2 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,7 +9,7 @@
       "version": "2.11.18",
       "dependencies": {
         "@bdelab/roam-fluency": "1.11.26",
-        "@bdelab/roar-firekit": "^8.0.8",
+        "@bdelab/roar-firekit": "^9.0.1",
         "@bdelab/roar-letter": "1.11.8",
         "@bdelab/roar-multichoice": "^1.11.3",
         "@bdelab/roar-pa": "2.2.4",
@@ -1848,9 +1848,9 @@
       }
     },
     "node_modules/@bdelab/roar-firekit": {
-      "version": "8.0.8",
-      "resolved": "https://registry.npmjs.org/@bdelab/roar-firekit/-/roar-firekit-8.0.8.tgz",
-      "integrity": "sha512-L69a3uQff8OYHFUP9i036N1NGon3y2YR0SLYbHwtNyulkXemtZqNbPxvJPokdupOOAsuw+MRMUxPJPJrxX8ocQ==",
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/@bdelab/roar-firekit/-/roar-firekit-9.0.1.tgz",
+      "integrity": "sha512-MscBltVjx0V1BsTP+n5/3Afwtp76DDe67CgeqrnCTClXgqUyq2KWzB9cndppVhr2Fk6XZWPbk5rrnAvjZpN6fw==",
       "license": "ISC",
       "dependencies": {
         "@bdelab/roar-firekit": "^4.1.1",
@@ -24790,7 +24790,6 @@
     },
     "node_modules/npm/node_modules/lodash._baseindexof": {
       "version": "3.1.0",
-      "extraneous": true,
       "inBundle": true,
       "license": "MIT"
     },
@@ -24815,19 +24814,16 @@
     },
     "node_modules/npm/node_modules/lodash._bindcallback": {
       "version": "3.0.1",
-      "extraneous": true,
       "inBundle": true,
       "license": "MIT"
     },
     "node_modules/npm/node_modules/lodash._cacheindexof": {
       "version": "3.0.2",
-      "extraneous": true,
       "inBundle": true,
       "license": "MIT"
     },
     "node_modules/npm/node_modules/lodash._createcache": {
       "version": "3.1.2",
-      "extraneous": true,
       "inBundle": true,
       "license": "MIT",
       "dependencies": {
@@ -24836,7 +24832,6 @@
     },
     "node_modules/npm/node_modules/lodash._getnative": {
       "version": "3.9.1",
-      "extraneous": true,
       "inBundle": true,
       "license": "MIT"
     },
@@ -24847,7 +24842,6 @@
     },
     "node_modules/npm/node_modules/lodash.restparam": {
       "version": "3.6.1",
-      "extraneous": true,
       "inBundle": true,
       "license": "MIT"
     },
@@ -38988,9 +38982,9 @@
       }
     },
     "@bdelab/roar-firekit": {
-      "version": "8.0.8",
-      "resolved": "https://registry.npmjs.org/@bdelab/roar-firekit/-/roar-firekit-8.0.8.tgz",
-      "integrity": "sha512-L69a3uQff8OYHFUP9i036N1NGon3y2YR0SLYbHwtNyulkXemtZqNbPxvJPokdupOOAsuw+MRMUxPJPJrxX8ocQ==",
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/@bdelab/roar-firekit/-/roar-firekit-9.0.1.tgz",
+      "integrity": "sha512-MscBltVjx0V1BsTP+n5/3Afwtp76DDe67CgeqrnCTClXgqUyq2KWzB9cndppVhr2Fk6XZWPbk5rrnAvjZpN6fw==",
       "requires": {
         "@bdelab/roar-firekit": "^4.1.1",
         "crc-32": "^1.2.2",
@@ -56414,8 +56408,7 @@
         },
         "lodash._baseindexof": {
           "version": "3.1.0",
-          "bundled": true,
-          "extraneous": true
+          "bundled": true
         },
         "lodash._baseuniq": {
           "version": "4.6.0",
@@ -56437,26 +56430,22 @@
         },
         "lodash._bindcallback": {
           "version": "3.0.1",
-          "bundled": true,
-          "extraneous": true
+          "bundled": true
         },
         "lodash._cacheindexof": {
           "version": "3.0.2",
-          "bundled": true,
-          "extraneous": true
+          "bundled": true
         },
         "lodash._createcache": {
           "version": "3.1.2",
           "bundled": true,
-          "extraneous": true,
           "requires": {
             "lodash._getnative": "^3.0.0"
           }
         },
         "lodash._getnative": {
           "version": "3.9.1",
-          "bundled": true,
-          "extraneous": true
+          "bundled": true
         },
         "lodash.clonedeep": {
           "version": "4.5.0",
@@ -56464,8 +56453,7 @@
         },
         "lodash.restparam": {
           "version": "3.6.1",
-          "bundled": true,
-          "extraneous": true
+          "bundled": true
         },
         "lodash.union": {
           "version": "4.6.0",
diff --git a/package.json b/package.json
index 96e0f1565..9af767ae2 100644
--- a/package.json
+++ b/package.json
@@ -32,7 +32,7 @@
   },
   "dependencies": {
     "@bdelab/roam-fluency": "1.11.26",
-    "@bdelab/roar-firekit": "^8.0.8",
+    "@bdelab/roar-firekit": "^9.0.1",
     "@bdelab/roar-letter": "1.11.8",
     "@bdelab/roar-multichoice": "^1.11.3",
     "@bdelab/roar-pa": "2.2.4",
diff --git a/src/App.vue b/src/App.vue
index ae4ad4dfa..7316fa2a9 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -88,11 +88,13 @@ onBeforeMount(async () => {
   authStore.setUser();
   await authStore.initStateFromRedirect().then(async () => {
     if (authStore.uid) {
-      const userData = await fetchDocById('users', authStore.uid);
       const userClaims = await fetchDocById('userClaims', authStore.uid);
-      authStore.userData = userData;
       authStore.userClaims = userClaims;
     }
+    if (authStore.roarUid) {
+      const userData = await fetchDocById('users', authStore.roarUid);
+      authStore.userData = userData;
+    }
   });
   isAuthStoreReady.value = true;
 });
diff --git a/src/components/CardAdministration.vue b/src/components/CardAdministration.vue
index 51cedd077..e87afe53d 100644
--- a/src/components/CardAdministration.vue
+++ b/src/components/CardAdministration.vue
@@ -19,7 +19,6 @@
             button-class="p-button-outlined p-button-sm w-3rem h-3rem border-primary border-1 border-circle bg-transparent hover:surface-300"
             :tooltip-options="{ position: 'top' }"
             :pt="{ button: { size: 'small' } }"
-            data-cy="button-speed-dial"
           />
           <PvConfirmPopup />
         </div>
@@ -94,7 +93,7 @@
         </PvColumn>
         <PvColumn field="id" header="" style="width: 14rem">
           <template #body="{ node }">
-            <div class="flex m-0">
+            <div v-if="node.data.id" class="flex m-0">
               <router-link
                 :to="{
                   name: 'ViewAdministration',
@@ -295,39 +294,56 @@ const fetchTreeOrgs = async () => {
     ),
   );
 
-  const promises = [batchGetDocs(orgPaths, ['name', 'schools', 'classes', 'districtId']), batchGetDocs(statsPaths)];
+  const promises = [
+    batchGetDocs(orgPaths, ['name', 'schools', 'classes', 'archivedSchools', 'archivedClasses', 'districtId']),
+    batchGetDocs(statsPaths),
+  ];
 
   const [orgDocs, statsDocs] = await Promise.all(promises);
 
-  const dsgfOrgs = _zip(orgDocs, statsDocs).map(([orgDoc, stats], index) => {
-    const { classes, schools, collection, ...nodeData } = orgDoc;
-    const node = {
-      key: String(index),
-      data: {
-        orgType: singularOrgTypes[collection],
-        schools,
-        classes,
-        stats,
-        ...nodeData,
-      },
-    };
-    if (classes)
-      node.children = classes.map((classId) => {
-        return {
-          key: `${node.key}-${classId}`,
-          data: {
-            orgType: 'class',
-            id: classId,
-          },
-        };
-      });
-    return node;
-  });
+  const dsgfOrgs = _without(
+    _zip(orgDocs, statsDocs).map(([orgDoc, stats], index) => {
+      if (!orgDoc || _isEmpty(orgDoc)) {
+        return undefined;
+      }
+      const { classes, schools, archivedSchools, archivedClasses, collection, ...nodeData } = orgDoc;
+      const node = {
+        key: String(index),
+        data: {
+          orgType: singularOrgTypes[collection],
+          schools,
+          classes,
+          archivedSchools,
+          archivedClasses,
+          stats,
+          ...nodeData,
+        },
+      };
+      if (classes || archivedClasses)
+        node.children = [...(classes ?? []), ...(archivedClasses ?? [])].map((classId) => {
+          return {
+            key: `${node.key}-${classId}`,
+            data: {
+              orgType: 'class',
+              id: classId,
+            },
+          };
+        });
+      return node;
+    }),
+    undefined,
+  );
 
-  const dependentSchoolIds = _flattenDeep(dsgfOrgs.map((node) => node.data.schools ?? []));
+  const districtIds = dsgfOrgs.filter((node) => node.data.orgType === 'district').map((node) => node.data.id);
+
+  const dependentSchoolIds = _flattenDeep(
+    dsgfOrgs.map((node) => [...(node.data.schools ?? []), ...(node.data.archivedSchools ?? [])]),
+  );
   const independentSchoolIds =
     dsgfOrgs.length > 0 ? _without(props.assignees.schools, ...dependentSchoolIds) : props.assignees.schools;
-  const dependentClassIds = _flattenDeep(dsgfOrgs.map((node) => node.data.classes ?? []));
+  const dependentClassIds = _flattenDeep(
+    dsgfOrgs.map((node) => [...(node.data.classes ?? []), ...(node.data.archivedClasses ?? [])]),
+  );
   const independentClassIds =
     dsgfOrgs.length > 0 ? _without(props.assignees.classes, ...dependentClassIds) : props.assignees.classes;
 
@@ -345,13 +361,13 @@ const fetchTreeOrgs = async () => {
   );
 
   const classPromises = [
-    batchGetDocs(independentClassPaths, ['name', 'schoolId']),
+    batchGetDocs(independentClassPaths, ['name', 'schoolId', 'districtId']),
     batchGetDocs(independentClassStatPaths),
   ];
 
   const [classDocs, classStats] = await Promise.all(classPromises);
 
-  const independentClasses = _without(
+  let independentClasses = _without(
     _zip(classDocs, classStats).map(([orgDoc, stats], index) => {
       const { collection = 'classes', ...nodeData } = orgDoc ?? {};
 
@@ -370,6 +386,12 @@ const fetchTreeOrgs = async () => {
     undefined,
   );
 
+  // These are classes that are directly under a district, without a school
+  // They were eroneously categorized as independent classes but now we need
+  // to remove them from the independent classes array
+  const directReportClasses = independentClasses.filter((node) => districtIds.includes(node.data.districtId));
+  independentClasses = independentClasses.filter((node) => !districtIds.includes(node.data.districtId));
+
   const treeTableOrgs = dsgfOrgs.filter((node) => node.data.orgType === 'district');
   treeTableOrgs.push(...independentSchools);
 
@@ -392,6 +414,42 @@ const fetchTreeOrgs = async () => {
     }
   }
 
+  for (const _class of directReportClasses) {
+    const districtId = _class.data.districtId;
+    const districtIndex = treeTableOrgs.findIndex((node) => node.data.id === districtId);
+    if (districtIndex !== -1) {
+      const directReportSchoolKey = `${treeTableOrgs[districtIndex].key}-9999`;
+      const directReportSchool = {
+        key: directReportSchoolKey,
+        data: {
+          orgType: 'school',
+          orgId: '9999',
+          name: 'Direct Report Classes',
+        },
+        children: [
+          {
+            ..._class,
+            key: `${directReportSchoolKey}-${_class.key}`,
+          },
+        ],
+      };
+      if (treeTableOrgs[districtIndex].children === undefined) {
+        treeTableOrgs[districtIndex].children = [directReportSchool];
+      } else {
+        const schoolIndex = treeTableOrgs[districtIndex].children.findIndex(
+          (node) => node.key === directReportSchoolKey,
+        );
+        if (schoolIndex === -1) {
+          treeTableOrgs[districtIndex].children.push(directReportSchool);
+        } else {
+          treeTableOrgs[districtIndex].children[schoolIndex].children.push(_class);
+        }
+      }
+    } else {
+      treeTableOrgs.push(_class);
+    }
+  }
+
   treeTableOrgs.push(...(independentClasses ?? []));
   treeTableOrgs.push(...dsgfOrgs.filter((node) => node.data.orgType === 'group'));
   treeTableOrgs.push(...dsgfOrgs.filter((node) => node.data.orgType === 'family'));
@@ -498,18 +556,23 @@ const onExpand = async (node) => {
       return n;
     });
 
-    // Sort the classes by existance of stats then alphabetically
-    (newNodes ?? []).forEach((districtNode) => {
-      (districtNode?.children ?? []).forEach((schoolNode) => {
+    // Sort the classes by existence of stats then alphabetically
+    // TODO: This fails currently as it tries to set a read only reactive handler
+    // Specifically, setting the `children` key fails because the
+    // schoolNode target is read-only.
+    // Also, I'm pretty sure this is useless now because all classes will have stats
+    // due to preallocation of accounts.
+    for (const districtNode of newNodes ?? []) {
+      for (const schoolNode of districtNode?.children ?? []) {
         if (schoolNode.children) {
-          schoolNode.children.sort((a, b) => {
+          schoolNode.children = schoolNode.children.toSorted((a, b) => {
             if (!a.data.stats) return 1;
             if (!b.data.stats) return -1;
             return a.data.name.localeCompare(b.data.name);
           });
         }
-      });
-    });
+      }
+    }
 
     treeTableOrgs.value = newNodes;
     expanding.value = false;
diff --git a/src/components/ListUsers.vue b/src/components/ListUsers.vue
index f5fad91bd..5a00fea0c 100644
--- a/src/components/ListUsers.vue
+++ b/src/components/ListUsers.vue
@@ -222,6 +222,12 @@ const columns = ref([
     dataType: 'string',
     sort: false,
   },
+  {
+    field: 'archived',
+    header: 'Archived',
+    dataType: 'boolean',
+    sort: false,
+  },
   {
     header: 'Edit',
     button: true,
@@ -305,7 +311,7 @@ async function updatePassword() {
   if (!v$.value.$invalid) {
     isSubmitting.value = true;
     await roarfirekit.value
-      .updateUserData(roarUid.value, { password: state.password })
+      .updateUserData(currentEditUser.value.id, { password: state.password })
       .then(() => {
         submitted.value = false;
         isSubmitting.value = false;
diff --git a/src/components/NavBar.vue b/src/components/NavBar.vue
index 6a2d33061..475c5a4bb 100644
--- a/src/components/NavBar.vue
+++ b/src/components/NavBar.vue
@@ -160,11 +160,8 @@ const userDisplayName = computed(() => {
     const displayName = authStore?.userData?.displayName;
     const username = authStore?.userData?.username;
     const firstName = authStore?.userData?.name?.first;
-    if (isAdmin.value === true) {
-      return 'Hi, ' + (displayName || username || email || 'Admin') + '!';
-    } else {
-      return 'Hi, ' + (firstName || displayName || username || email || 'User') + '! 👋';
-    }
+    const userType = isAdmin.value ? 'Admin' : 'User';
+    return `Hi, ${firstName || displayName || username || email || userType}!`;
   }
 });
 
diff --git a/src/helpers/query/administrations.js b/src/helpers/query/administrations.js
index 4405496e0..1dc69e7a7 100644
--- a/src/helpers/query/administrations.js
+++ b/src/helpers/query/administrations.js
@@ -1,9 +1,10 @@
 import _chunk from 'lodash/chunk';
-import _flatten from 'lodash/flatten';
+import _last from 'lodash/last';
 import _mapValues from 'lodash/mapValues';
-import _uniqBy from 'lodash/uniqBy';
 import _without from 'lodash/without';
-import { convertValues, getAxiosInstance, mapFields, orderByDefault } from './utils';
+import { storeToRefs } from 'pinia';
+import { useAuthStore } from '@/store/auth';
+import { convertValues, getAxiosInstance, orderByDefault } from './utils';
 import { filterAdminOrgs } from '@/helpers';
 
 export function getTitle(item, isSuperAdmin) {
@@ -15,130 +16,6 @@ export function getTitle(item, isSuperAdmin) {
   }
 }
 
-const getAdministrationsRequestBody = ({
-  orderBy,
-  aggregationQuery,
-  paginate = true,
-  page,
-  pageLimit,
-  skinnyQuery = false,
-  assigningOrgCollection,
-  assigningOrgIds,
-  testData = false,
-}) => {
-  const requestBody = {
-    structuredQuery: {
-      orderBy: orderBy ?? orderByDefault,
-    },
-  };
-
-  if (!aggregationQuery) {
-    if (paginate) {
-      requestBody.structuredQuery.limit = pageLimit;
-      requestBody.structuredQuery.offset = page * pageLimit;
-    }
-
-    if (skinnyQuery) {
-      requestBody.structuredQuery.select = {
-        fields: [{ fieldPath: 'id' }, { fieldPath: 'name' }],
-      };
-    } else {
-      requestBody.structuredQuery.select = {
-        fields: [
-          { fieldPath: 'id' },
-          { fieldPath: 'name' },
-          { fieldPath: 'publicName' },
-          { fieldPath: 'assessments' },
-          { fieldPath: 'dateClosed' },
-          { fieldPath: 'dateCreated' },
-          { fieldPath: 'dateOpened' },
-          { fieldPath: 'districts' },
-          { fieldPath: 'schools' },
-          { fieldPath: 'classes' },
-          { fieldPath: 'groups' },
-          { fieldPath: 'families' },
-          { fieldPath: 'testData' },
-        ],
-      };
-    }
-  }
-
-  requestBody.structuredQuery.from = [
-    {
-      collectionId: 'administrations',
-      allDescendants: false,
-    },
-  ];
-  const filters = [];
-
-  // If we're fetching test data, we don't need to filter by assigningOrgs as a super admin
-  // This assumes that the document has a testData field that is a boolean
-  if (testData === true) {
-    filters.push({
-      fieldFilter: {
-        field: { fieldPath: 'testData' },
-        op: 'EQUAL',
-        value: { booleanValue: true },
-      },
-    });
-  } else {
-    // Else only fetch data not marked as test data
-    // This assumes that the document has a testData field that is a boolean
-    filters.push({
-      fieldFilter: {
-        field: { fieldPath: 'testData' },
-        op: 'EQUAL',
-        value: { booleanValue: false },
-      },
-    });
-
-    // If we're not a super admin, we need to filter by assigningOrgs
-    // Non-super admin users do not have access to test data
-    if (assigningOrgCollection && assigningOrgIds) {
-      filters.push({
-        fieldFilter: {
-          field: { fieldPath: `readOrgs.${assigningOrgCollection}` },
-          op: 'ARRAY_CONTAINS_ANY',
-          value: {
-            arrayValue: {
-              values: assigningOrgIds.map((orgId) => ({ stringValue: orgId })),
-            },
-          },
-        },
-      });
-    }
-  }
-
-  // If we have filters, add them to the request body
-  if (filters.length > 0) {
-    requestBody.structuredQuery.where =
-      filters.length === 1
-        ? filters[0]
-        : {
-            compositeFilter: {
-              op: 'AND',
-              filters: filters,
-            },
-          };
-  }
-
-  if (aggregationQuery) {
-    return {
-      structuredAggregationQuery: {
-        ...requestBody,
-        aggregations: [
-          {
-            alias: 'count',
-            count: {},
-          },
-        ],
-      },
-    };
-  }
-
-  return requestBody;
-};
-
 const processBatchStats = async (axiosInstance, statsPaths, batchSize = 5) => {
   const batchStatsDocs = [];
   const statsPathChunks = _chunk(statsPaths, batchSize);
@@ -166,87 +43,43 @@ const processBatchStats = async (axiosInstance, statsPaths, batchSize = 5) => {
   return batchStatsDocs;
 };
 
-export const administrationCounter = async (orderBy, isSuperAdmin, adminOrgs) => {
-  const axiosInstance = getAxiosInstance();
-  if (isSuperAdmin.value) {
-    const requestBody = getAdministrationsRequestBody({
-      aggregationQuery: true,
-      orderBy: orderBy.value,
-      paginate: false,
-      skinnyQuery: true,
-    });
-    console.log(`Fetching count for administrations`);
-    return axiosInstance.post(':runAggregationQuery', requestBody).then(({ data }) => {
-      return Number(convertValues(data[0].result?.aggregateFields?.count));
-    });
-  } else {
-    const promises = [];
-    // Iterate through each adminOrg type
-    for (const [orgType, orgIds] of Object.entries(adminOrgs.value)) {
-      // Then chunk those arrays into chunks of 10
-      if ((orgIds ?? []).length > 0) {
-        const requestBodies = _chunk(orgIds, 10).map((orgChunk) =>
-          getAdministrationsRequestBody({
-            aggregationQuery: false,
-            paginate: false,
-            skinnyQuery: true,
-            assigningOrgCollection: orgType,
-            assigningOrgIds: orgChunk,
-          }),
-        );
-
-        promises.push(
-          requestBodies.map((requestBody) =>
-            axiosInstance.post(':runQuery', requestBody).then(async ({ data }) => {
-              return mapFields(data);
-            }),
-          ),
-        );
-      }
-    }
-
-    const flattened = _flatten(await Promise.all(_flatten(promises)));
-    const orderField = (orderBy?.value ?? orderByDefault)[0].field.fieldPath;
-    const administrations = _uniqBy(flattened, 'id').filter((a) => a[orderField] !== undefined);
-    return administrations.length;
-  }
-};
-
 const mapAdministrations = async ({ isSuperAdmin, data, adminOrgs }) => {
   // First format the administration documents
-  const administrationData = mapFields(data).map((a) => {
-    let assignedOrgs = {
-      districts: a.districts,
-      schools: a.schools,
-      classes: a.classes,
-      groups: a.groups,
-      families: a.families,
-    };
-    if (!isSuperAdmin.value) {
-      assignedOrgs = filterAdminOrgs(adminOrgs.value, assignedOrgs);
-    }
-    return {
-      id: a.id,
-      name: a.name,
-      publicName: a.publicName,
-      dates: {
-        start: a.dateOpened,
-        end: a.dateClosed,
-        created: a.dateCreated,
-      },
-      assessments: a.assessments,
-      assignedOrgs,
-      // If testData is not defined, default to false when mapping
-      testData: a.testData ?? false,
-    };
-  });
+  const administrationData = data
+    .map((a) => a.data)
+    .map((a) => {
+      let assignedOrgs = {
+        districts: a.districts,
+        schools: a.schools,
+        classes: a.classes,
+        groups: a.groups,
+        families: a.families,
+      };
+      if (!isSuperAdmin.value) {
+        assignedOrgs = filterAdminOrgs(adminOrgs.value, assignedOrgs);
+      }
+      return {
+        id: a.id,
+        name: a.name,
+        publicName: a.publicName,
+        dates: {
+          start: a.dateOpened,
+          end: a.dateClosed,
+          created: a.dateCreated,
+        },
+        assessments: a.assessments,
+        assignedOrgs,
+        // If testData is not defined, default to false when mapping
+        testData: a.testData ?? false,
+      };
+    });
 
   // Create a list of all the stats document paths we need to get
   const statsPaths = data
     // First filter out any missing administration documents
-    .filter((item) => item.document !== undefined)
+    .filter((item) => item.name !== undefined)
     // Then map to the total stats document
-    .map(({ document }) => `${document.name}/stats/total`);
+    .map(({ name }) => `${name}/stats/total`);
 
   const axiosInstance = getAxiosInstance();
   const batchStatsDocs = await processBatchStats(axiosInstance, statsPaths);
@@ -262,66 +95,48 @@ const mapAdministrations = async ({ isSuperAdmin, data, adminOrgs }) => {
   return administrations;
 };
 
-export const administrationPageFetcher = async (
-  orderBy,
-  pageLimit,
-  page,
-  isSuperAdmin,
-  adminOrgs,
-  exhaustiveAdminOrgs,
-  fetchTestData = false,
-) => {
+export const administrationPageFetcher = async (isSuperAdmin, exhaustiveAdminOrgs, fetchTestData = false, orderBy) => {
+  const authStore = useAuthStore();
+  const { roarfirekit } = storeToRefs(authStore);
+  const administrationIds = await roarfirekit.value.getAdministrations({ testData: fetchTestData });
+
   const axiosInstance = getAxiosInstance();
-  if (isSuperAdmin.value) {
-    const requestBody = getAdministrationsRequestBody({
-      aggregationQuery: false,
-      orderBy: orderBy.value,
-      paginate: true,
-      page: page.value,
-      skinnyQuery: false,
-      pageLimit: pageLimit.value,
-      testData: fetchTestData,
-    });
-    console.log(`Fetching page ${page.value} for administrations`);
-    return axiosInstance.post(':runQuery', requestBody).then(async ({ data }) => {
-      return mapAdministrations({ isSuperAdmin, data, adminOrgs });
-    });
-  } else {
-    const promises = [];
-    // Iterate through each adminOrg type
-    for (const [orgType, orgIds] of Object.entries(adminOrgs.value)) {
-      // Then chunk those arrays into chunks of 10
-      if ((orgIds ?? []).length > 0) {
-        const requestBodies = _chunk(orgIds, 10).map((orgChunk) =>
-          getAdministrationsRequestBody({
-            aggregationQuery: false,
-            paginate: false,
-            skinnyQuery: false,
-            assigningOrgCollection: orgType,
-            assigningOrgIds: orgChunk,
-          }),
-        );
-        // Map all of those request bodies into axios promises
-        promises.push(
-          requestBodies.map((requestBody) =>
-            axiosInstance.post(':runQuery', requestBody).then(async ({ data }) => {
-              return mapAdministrations({ isSuperAdmin, data, adminOrgs: exhaustiveAdminOrgs });
-            }),
-          ),
-        );
+  const documentPrefix = axiosInstance.defaults.baseURL.replace('https://firestore.googleapis.com/v1/', '');
+  const documents = administrationIds.map((id) => `${documentPrefix}/administrations/${id}`);
+
+  const { data } = await axiosInstance.post(':batchGet', { documents });
+
+  const administrationData = _without(
+    data.map(({ found }) => {
+      if (found) {
+        return {
+          name: found.name,
+          data: {
+            id: _last(found.name.split('/')),
+            ..._mapValues(found.fields, (value) => convertValues(value)),
+          },
+        };
       }
-    }
+      return undefined;
+    }),
+    undefined,
+  );
+
+  const administrations = await mapAdministrations({
+    isSuperAdmin,
+    data: administrationData,
+    adminOrgs: exhaustiveAdminOrgs,
+  });
 
-    const orderField = (orderBy?.value ?? orderByDefault)[0].field.fieldPath;
-    const orderDirection = (orderBy?.value ?? orderByDefault)[0].direction;
-    const flattened = _flatten(await Promise.all(_flatten(promises)));
-    const administrations = _uniqBy(flattened, 'id')
-      .filter((a) => a[orderField] !== undefined)
-      .sort((a, b) => {
-        if (orderDirection === 'ASCENDING') return 2 * +(a[orderField] > b[orderField]) - 1;
-        if (orderDirection === 'DESCENDING') return 2 * +(b[orderField] > a[orderField]) - 1;
-        return 0;
-      });
-    return administrations.slice(page.value * pageLimit.value, (page.value + 1) * pageLimit.value);
-  }
+  const orderField = (orderBy?.value ?? orderByDefault)[0].field.fieldPath;
+  const orderDirection = (orderBy?.value ?? orderByDefault)[0].direction;
+  const sortedAdministrations = administrations
+    .filter((a) => a[orderField] !== undefined)
+    .sort((a, b) => {
+      if (orderDirection === 'ASCENDING') return 2 * +(a[orderField] > b[orderField]) - 1;
+      if (orderDirection === 'DESCENDING') return 2 * +(b[orderField] > a[orderField]) - 1;
+      return 0;
+    });
+
+  return sortedAdministrations;
 };
diff --git a/src/helpers/query/assignments.js b/src/helpers/query/assignments.js
index 2d79091ca..7552c2319 100644
--- a/src/helpers/query/assignments.js
+++ b/src/helpers/query/assignments.js
@@ -20,9 +20,13 @@ const assignmentSelectFields = [
   'dateAssigned',
   'dateClosed',
   'dateOpened',
+  'id',
+  'legal',
+  'name',
+  'publicName',
   'readOrgs',
+  'sequential',
   'started',
-  'id',
 ];
 
 export const getAssignmentsRequestBody = ({
@@ -173,90 +177,6 @@ export const getAssignmentsRequestBody = ({
   return requestBody;
 };
 
-export const getUsersByAssignmentIdRequestBody = ({
-  adminId,
-  orgType,
-  orgId,
-  filter,
-  aggregationQuery,
-  pageLimit,
-  page,
-  paginate = true,
-  select = userSelectFields,
-}) => {
-  const requestBody = {
-    structuredQuery: {},
-  };
-
-  if (!aggregationQuery) {
-    if (paginate) {
-      requestBody.structuredQuery.limit = pageLimit;
-      requestBody.structuredQuery.offset = page * pageLimit;
-    }
-
-    if (select.length > 0) {
-      requestBody.structuredQuery.select = {
-        fields: select.map((field) => ({ fieldPath: field })),
-      };
-    }
-  }
-
-  requestBody.structuredQuery.from = [
-    {
-      collectionId: 'users',
-      allDescendants: false,
-    },
-  ];
-
-  requestBody.structuredQuery.where = {
-    compositeFilter: {
-      op: 'AND',
-      filters: [
-        {
-          fieldFilter: {
-            field: { fieldPath: `${pluralizeFirestoreCollection(orgType)}.current` },
-            op: 'ARRAY_CONTAINS',
-            value: { stringValue: orgId },
-          },
-        },
-        {
-          fieldFilter: {
-            field: { fieldPath: `assignments.assigned` },
-            op: 'ARRAY_CONTAINS_ANY',
-            value: { arrayValue: { values: [{ stringValue: adminId }] } },
-          },
-        },
-      ],
-    },
-  };
-
-  if (filter) {
-    requestBody.structuredQuery.where.compositeFilter.filters.push({
-      fieldFilter: {
-        field: { fieldPath: filter[0].field },
-        op: 'EQUAL',
-        value: { stringValue: filter[0].value },
-      },
-    });
-  }
-
-  if (aggregationQuery) {
-    return {
-      structuredAggregationQuery: {
-        ...requestBody,
-        aggregations: [
-          {
-            alias: 'count',
-            count: {},
-          },
-        ],
-      },
-    };
-  }
-
-  return requestBody;
-};
-
 export const getFilteredScoresRequestBody = ({
   adminId,
   orgId,
diff --git a/src/helpers/query/orgs.js b/src/helpers/query/orgs.js
index f569c0d58..0af0f8564 100644
--- a/src/helpers/query/orgs.js
+++ b/src/helpers/query/orgs.js
@@ -49,77 +49,82 @@ export const getOrgsRequestBody = ({
     },
   ];
 
+  requestBody.structuredQuery.where = {
+    compositeFilter: {
+      op: 'AND',
+      filters: [
+        {
+          fieldFilter: {
+            field: { fieldPath: 'archived' },
+            op: 'EQUAL',
+            value: { booleanValue: false },
+          },
+        },
+      ],
+    },
+  };
+
   if (orgName && !(parentDistrict || parentSchool)) {
-    requestBody.structuredQuery.where = {
+    requestBody.structuredQuery.where.compositeFilter.filters.push({
       fieldFilter: {
         field: { fieldPath: 'name' },
         op: 'EQUAL',
         value: { stringValue: orgName },
       },
-    };
+    });
   } else if (orgType === 'schools' && parentDistrict) {
     if (orgName) {
-      requestBody.structuredQuery.where = {
-        compositeFilter: {
-          op: 'AND',
-          filters: [
-            {
-              fieldFilter: {
-                field: { fieldPath: 'name' },
-                op: 'EQUAL',
-                value: { stringValue: orgName },
-              },
-            },
-            {
-              fieldFilter: {
-                field: { fieldPath: 'districtId' },
-                op: 'EQUAL',
-                value: { stringValue: parentDistrict },
-              },
-            },
-          ],
+      requestBody.structuredQuery.where.compositeFilter.filters.push(
+        {
+          fieldFilter: {
+            field: { fieldPath: 'name' },
+            op: 'EQUAL',
+            value: { stringValue: orgName },
+          },
         },
-      };
+        {
+          fieldFilter: {
+            field: { fieldPath: 'districtId' },
+            op: 'EQUAL',
+            value: { stringValue: parentDistrict },
+          },
+        },
+      );
     } else {
-      requestBody.structuredQuery.where = {
+      requestBody.structuredQuery.where.compositeFilter.filters.push({
         fieldFilter: {
           field: { fieldPath: 'districtId' },
           op: 'EQUAL',
           value: { stringValue: parentDistrict },
         },
-      };
+      });
     }
   } else if (orgType === 'classes' && parentSchool) {
     if (orgName) {
-      requestBody.structuredQuery.where = {
-        compositeFilter: {
-          op: 'AND',
-          filters: [
-            {
-              fieldFilter: {
-                field: { fieldPath: 'name' },
-                op: 'EQUAL',
-                value: { stringValue: orgName },
-              },
-            },
-            {
-              fieldFilter: {
-                field: { fieldPath: 'schoolId' },
-                op: 'EQUAL',
-                value: { stringValue: parentSchool },
-              },
-            },
-          ],
+      requestBody.structuredQuery.where.compositeFilter.filters.push(
+        {
+          fieldFilter: {
+            field: { fieldPath: 'name' },
+            op: 'EQUAL',
+            value: { stringValue: orgName },
+          },
         },
-      };
+        {
+          fieldFilter: {
+            field: { fieldPath: 'schoolId' },
+            op: 'EQUAL',
+            value: { stringValue: parentSchool },
+          },
+        },
+      );
     } else {
-      requestBody.structuredQuery.where = {
+      requestBody.structuredQuery.where.compositeFilter.filters.push({
         fieldFilter: {
           field: { fieldPath: 'schoolId' },
           op: 'EQUAL',
           value: { stringValue: parentSchool },
         },
-      };
+      });
     }
   }
 
diff --git a/src/helpers/query/users.js b/src/helpers/query/users.js
index 5ff0837d9..1e7e8fb0e 100644
--- a/src/helpers/query/users.js
+++ b/src/helpers/query/users.js
@@ -10,6 +10,7 @@ export const getUsersRequestBody = ({
   paginate = true,
   select = ['name'],
   orderBy,
+  restrictToActiveUsers = false,
 }) => {
   const requestBody = {
     structuredQuery: {},
@@ -36,8 +37,25 @@ export const getUsersRequestBody = ({
     },
   ];
 
+  requestBody.structuredQuery.where = {
+    compositeFilter: {
+      op: 'AND',
+      filters: [],
+    },
+  };
+
+  if (restrictToActiveUsers) {
+    requestBody.structuredQuery.where.compositeFilter.filters.push({
+      fieldFilter: {
+        field: { fieldPath: 'archived' },
+        op: 'EQUAL',
+        value: { booleanValue: false },
+      },
+    });
+  }
+
   if (userIds.length > 0) {
-    requestBody.structuredQuery.where = {
+    requestBody.structuredQuery.where.compositeFilter.filters.push({
       fieldFilter: {
         field: { fieldPath: 'id' }, // change this to accept document Id, if we need
         op: 'IN',
@@ -51,15 +69,15 @@ export const getUsersRequestBody = ({
           },
         },
       },
-    };
+    });
   } else if (orgType && orgId) {
-    requestBody.structuredQuery.where = {
+    requestBody.structuredQuery.where.compositeFilter.filters.push({
       fieldFilter: {
         field: { fieldPath: `${orgType}.current` }, // change this to accept document Id, if we need
         op: 'ARRAY_CONTAINS',
         value: { stringValue: orgId },
       },
-    };
+    });
   } else {
     throw new Error('Must provide either userIds or orgType and orgId');
   }
@@ -81,21 +99,7 @@ export const getUsersRequestBody = ({
   return requestBody;
 };
 
-export const usersPageFetcher = async (userIds, pageLimit, page) => {
-  const axiosInstance = getAxiosInstance();
-  const requestBody = getUsersRequestBody({
-    userIds,
-    aggregationQuery: false,
-    pageLimit: pageLimit.value,
-    page: page.value,
-    paginate: true,
-  });
-
-  console.log(`Fetching page ${page.value} for ${userIds}`);
-  return axiosInstance.post(':runQuery', requestBody).then(({ data }) => mapFields(data));
-};
-
-export const fetchUsersByOrg = async (orgType, orgId, pageLimit, page, orderBy) => {
+export const fetchUsersByOrg = async (orgType, orgId, pageLimit, page, orderBy, restrictToActiveUsers = false) => {
   const axiosInstance = getAxiosInstance();
   const requestBody = getUsersRequestBody({
     orgType,
@@ -104,15 +108,16 @@ export const fetchUsersByOrg = async (orgType, orgId, pageLimit, page, orderBy)
     pageLimit: pageLimit.value,
     page: page.value,
     paginate: true,
-    select: ['username', 'name', 'studentData', 'userType'],
+    select: ['username', 'name', 'studentData', 'userType', 'archived'],
     orderBy: orderBy.value,
+    restrictToActiveUsers: restrictToActiveUsers,
   });
 
   console.log(`Fetching users page ${page.value} for ${orgType} ${orgId}`);
   return axiosInstance.post(':runQuery', requestBody).then(({ data }) => mapFields(data));
 };
 
-export const countUsersByOrg = async (orgType, orgId, orderBy) => {
+export const countUsersByOrg = async (orgType, orgId, orderBy, restrictToActiveUsers = false) => {
   const axiosInstance = getAxiosInstance();
   const requestBody = getUsersRequestBody({
     orgType,
@@ -120,6 +125,7 @@ export const countUsersByOrg = async (orgType, orgId, orderBy) => {
     aggregationQuery: true,
     paginate: false,
     orderBy: orderBy.value,
+    restrictToActiveUsers: restrictToActiveUsers,
   });
 
   return axiosInstance.post(':runAggregationQuery', requestBody).then(({ data }) => {
diff --git a/src/helpers/query/utils.js b/src/helpers/query/utils.js
index 527d786b5..8c6b6a9ca 100644
--- a/src/helpers/query/utils.js
+++ b/src/helpers/query/utils.js
@@ -170,9 +170,9 @@ export const fetchDocsById = async (documents, db = 'admin') => {
 
 export const batchGetDocs = async (docPaths, select = [], db = 'admin') => {
   if (_isEmpty(docPaths)) {
-    console.warn('BatchGetDocs: No document paths provided!');
     return [];
   }
+
   const axiosInstance = getAxiosInstance(db);
   const baseURL = axiosInstance.defaults.baseURL.split('googleapis.com/v1/')[1];
   const documents = docPaths.map((docPath) => `${baseURL}/${docPath}`);
diff --git a/src/pages/HomeAdministrator.vue b/src/pages/HomeAdministrator.vue
index 32d8ac183..333059a89 100644
--- a/src/pages/HomeAdministrator.vue
+++ b/src/pages/HomeAdministrator.vue
@@ -67,8 +67,8 @@
             </PvButton>
           </div>
         </div>
-        <div v-if="initialized && !isLoadingAdministrations">
-          <PvBlockUI :blocked="isFetchingAdministrations">
+        <div v-if="initialized && !fetchingAdministrations">
+          <PvBlockUI :blocked="fetchingAdministrations">
             <PvDataView
               :key="dataViewKey"
               :value="filteredAdministrations"
@@ -158,34 +158,29 @@ const orderBy = ref(orderByDefault);
 const fetchTestAdministrations = ref(false);
 const testAdminsCached = ref(false);
 
-const adminOrgs = computed(() => userClaims.value?.claims?.minimalAdminOrgs);
 const exhaustiveAdminOrgs = computed(() => userClaims.value?.claims?.adminOrgs);
 const isSuperAdmin = computed(() => Boolean(userClaims.value?.claims?.super_admin));
 const canQueryAdministrations = computed(() => {
   return initialized.value && !isLoadingClaims.value;
 });
 
+const isFetchingCachedAdministrations = ref(false);
+
 /**
  * Fetches administrations from the cache or the server
  * @param {Array} queryKey - The query key to use for fetching the data
  * @returns {Promise<unknown>} - The cached or fetched data
  */
 const getAdministrations = async (queryKey) => {
+  isFetchingCachedAdministrations.value = true;
+
   let cachedData = await queryClient.getQueryData(queryKey);
 
   if (!cachedData) {
     cachedData = await queryClient.fetchQuery({
       queryKey,
       queryFn: () =>
-        administrationPageFetcher(
-          orderBy,
-          ref(10000),
-          ref(0),
-          isSuperAdmin,
-          adminOrgs,
-          exhaustiveAdminOrgs,
-          fetchTestAdministrations.value,
-        ),
+        administrationPageFetcher(isSuperAdmin, exhaustiveAdminOrgs, fetchTestAdministrations.value, orderBy),
       keepPreviousData: true,
       enabled: canQueryAdministrations,
       staleTime: 5 * 60 * 1000, // 5 minutes
@@ -193,6 +188,7 @@ const getAdministrations = async (queryKey) => {
     testAdminsCached.value = true;
   }
 
+  isFetchingCachedAdministrations.value = false;
   return cachedData;
 };
 
@@ -205,22 +201,9 @@ const { isLoading: isLoadingClaims, data: userClaims } = useQuery({
   cacheTime: Infinity,
 });
 
-const {
-  isLoading: isLoadingAdministrations,
-  isFetching: isFetchingAdministrations,
-  data: administrations,
-} = useQuery({
-  queryKey: ['administrations', uid, orderBy, ref(0), ref(10000), isSuperAdmin, administrationQueryKeyIndex],
-  queryFn: () =>
-    administrationPageFetcher(
-      orderBy,
-      ref(10000),
-      ref(0),
-      isSuperAdmin,
-      adminOrgs,
-      exhaustiveAdminOrgs,
-      fetchTestAdministrations,
-    ),
+const { isFetching: isFetchingAdministrations, data: administrations } = useQuery({
+  queryKey: ['administrations', uid, isSuperAdmin, administrationQueryKeyIndex, fetchTestAdministrations.value],
+  queryFn: () => administrationPageFetcher(isSuperAdmin, exhaustiveAdminOrgs, fetchTestAdministrations.value, orderBy),
   keepPreviousData: true,
   enabled: canQueryAdministrations,
   staleTime: 5 * 60 * 1000, // 5 minutes
@@ -240,12 +223,14 @@ const {
   },
 });
 
+const fetchingAdministrations = computed(() => {
+  return isFetchingAdministrations.value || isFetchingCachedAdministrations.value;
+});
+
 const filteredAdministrations = ref(administrations.value);
 
 watch(fetchTestAdministrations, async (newState) => {
-  const queryKey = newState
-    ? ['testAdministrations', uid, orderBy, ref(0), ref(10000), isSuperAdmin, administrationQueryKeyIndex]
-    : ['administrations', uid, orderBy, ref(0), ref(10000), isSuperAdmin, administrationQueryKeyIndex];
+  const queryKey = ['administrations', uid, isSuperAdmin, administrationQueryKeyIndex, newState];
 
   filteredAdministrations.value = await getAdministrations(queryKey);
 });
diff --git a/src/pages/HomeParticipant.vue b/src/pages/HomeParticipant.vue
index 397311a2d..89caf8f18 100644
--- a/src/pages/HomeParticipant.vue
+++ b/src/pages/HomeParticipant.vue
@@ -6,8 +6,8 @@
         <span>{{ $t('homeParticipant.loadingAssignments') }}</span>
       </div>
       <div v-else>
-        <h2 v-if="adminInfo?.length == 1" class="p-float-label dropdown-container">
-          {{ adminInfo.at(0).publicName || adminInfo.at(0).name }}
+        <h2 v-if="assignmentInfo?.length == 1" class="p-float-label dropdown-container">
+          {{ assignmentInfo.at(0).publicName || assignmentInfo.at(0).name }}
         </h2>
         <div class="flex flex-row-reverse align-items-end gap-2 justify-content-between">
           <div
@@ -24,13 +24,13 @@
             }}</label>
           </div>
           <div
-            v-if="adminInfo?.length > 0"
+            v-if="assignmentInfo?.length > 0"
             class="flex flex-row justify-center align-items-center p-float-label dropdown-container gap-4 w-full"
           >
             <div class="assignment-select-container flex flex-row justify-content-between justify-content-start">
               <div class="flex flex-column align-content-start justify-content-start w-3">
                 <PvDropdown
-                  v-if="adminInfo.every((admin) => admin.publicName)"
+                  v-if="assignmentInfo.every((admin) => admin.publicName)"
                   v-model="selectedAdmin"
                   :options="sortedAdminInfo ?? []"
                   option-label="publicName"
@@ -169,38 +169,14 @@ const {
   refetchOnWindowFocus: 'always',
 });
 
-const administrationIds = computed(() => (assignmentInfo.value ?? []).map((assignment) => assignment.id));
-const administrationQueryEnabled = computed(() => !isLoadingAssignments.value);
-
-const {
-  isLoading: isLoadingAdmins,
-  isFetching: isFetchingAdmins,
-  data: adminInfo,
-} = useQuery({
-  queryKey: ['administrations', uid, administrationIds],
-  queryFn: () =>
-    fetchDocsById(
-      administrationIds.value.map((administrationId) => {
-        return {
-          collection: 'administrations',
-          docId: administrationId,
-          select: ['name', 'publicName', 'sequential', 'assessments', 'legal'],
-        };
-      }),
-    ),
-  keepPreviousData: true,
-  enabled: administrationQueryEnabled,
-  staleTime: 5 * 60 * 1000,
-});
-
 const sortedAdminInfo = computed(() => {
-  return [...(adminInfo.value ?? [])].sort((a, b) => a.name.localeCompare(b.name));
+  return [...(assignmentInfo.value ?? [])].sort((a, b) => (a.name || '').localeCompare(b.name || ''));
 });
 
 async function checkConsent() {
   showConsent.value = false;
   const dob = new Date(userData.value?.studentData?.dob);
-  const grade = userData.value?.studentData.grade;
+  const grade = userData.value?.studentData?.grade;
   const currentDate = new Date();
   const age = currentDate.getFullYear() - dob.getFullYear();
   const legal = selectedAdmin.value?.legal;
@@ -318,11 +294,11 @@ const { data: surveyResponsesData } = useQuery({
 });
 
 const isLoading = computed(() => {
-  return isLoadingUserData.value || isLoadingAssignments.value || isLoadingAdmins.value || isLoadingTasks.value;
+  return isLoadingUserData.value || isLoadingAssignments.value || isLoadingTasks.value;
 });
 
 const isFetching = computed(() => {
-  return isFetchingUserData.value || isFetchingAssignments.value || isFetchingAdmins.value || isFetchingTasks.value;
+  return isFetchingUserData.value || isFetchingAssignments.value || isFetchingTasks.value;
 });
 
 const noGamesAvailable = computed(() => {
@@ -393,7 +369,7 @@ const optionalAssessments = computed(() => {
 const isSequential = computed(() => {
   return (
     _get(
-      _find(adminInfo.value, (admin) => {
+      _find(assignmentInfo.value, (admin) => {
         return admin.id === selectedAdmin.value.id;
       }),
       'sequential',
@@ -422,18 +398,22 @@ const studentInfo = computed(() => {
 });
 
 watch(
-  [selectedAdmin, adminInfo],
+  [selectedAdmin, assignmentInfo],
   async ([updateSelectedAdmin]) => {
     if (updateSelectedAdmin) {
       await checkConsent();
     }
     const selectedAdminId = selectedAdmin.value?.id;
-    const allAdminIds = (adminInfo.value ?? []).map((admin) => admin.id);
+    const allAdminIds = (assignmentInfo.value ?? []).map((admin) => admin.id);
     // If there is no selected admin or if the selected admin is not in the list
     // of all administrations choose the first one after sorting alphabetically by publicName
     if (allAdminIds.length > 0 && (!selectedAdminId || !allAdminIds.includes(selectedAdminId))) {
       // Choose the first sorted administration
       selectedAdmin.value = sortedAdminInfo.value[0];
+    } else {
+      // N.B. Although this seems redundant, we ensure that the selected admin is a fresh instance of the admin.
+      //   This is relevant in the case that the game store does not flush properly.
+      selectedAdmin.value = sortedAdminInfo.value.find((admin) => admin.id === selectedAdminId);
     }
   },
   { immediate: true },
diff --git a/src/pages/HomeSelector.vue b/src/pages/HomeSelector.vue
index 17cc7c267..081b07b89 100644
--- a/src/pages/HomeSelector.vue
+++ b/src/pages/HomeSelector.vue
@@ -25,6 +25,7 @@ import { useRouter } from 'vue-router';
 import { useAuthStore } from '@/store/auth';
 import { useGameStore } from '@/store/game';
 import _get from 'lodash/get';
+import _isArray from 'lodash/isArray';
 import _isEmpty from 'lodash/isEmpty';
 import _union from 'lodash/union';
 import { storeToRefs } from 'pinia';
@@ -126,7 +127,8 @@ async function checkConsent() {
       return;
     }
 
-    const legalDocs = _get(toRaw(consentStatus), consentDoc.version);
+    let legalDocs = _get(toRaw(consentStatus), consentDoc.version);
+    legalDocs = _isArray(legalDocs) ? legalDocs : [legalDocs];
     const signedBeforeAugFirst = legalDocs.some((doc) => isSignedBeforeAugustFirst(doc.dateSigned));
 
     if (signedBeforeAugFirst) {
@@ -143,11 +145,15 @@ function isSignedBeforeAugustFirst(signedDate) {
 }
 
 // Only check consent if the user data is loaded
-watch(userData, async (newValue) => {
-  if (!_isEmpty(newValue)) {
-    await checkConsent();
-  }
-});
+watch(
+  [userData, userClaims],
+  async ([newUserData, newUserClaims]) => {
+    if (!_isEmpty(newUserData) && !_isEmpty(newUserClaims)) {
+      await checkConsent();
+    }
+  },
+  { immediate: true },
+);
 
 onMounted(async () => {
   if (requireRefresh.value) {
diff --git a/src/pages/ScoreReport.vue b/src/pages/ScoreReport.vue
index a6360a71c..fee44066b 100644
--- a/src/pages/ScoreReport.vue
+++ b/src/pages/ScoreReport.vue
@@ -125,7 +125,6 @@
             :page-limit="pageLimit"
             :loading="isLoadingScores || isFetchingScores"
             :groupheaders="true"
-            :lazy-pre-sorting="orderBy"
             data-cy="roar-data-table"
             @reset-filters="resetFilters"
             @export-all="exportAll"
@@ -420,23 +419,6 @@ const handleExportToPdf = async () => {
   return;
 };
 
-const orderBy = ref([
-  {
-    field: 'user.grade',
-    order: '1',
-  },
-  {
-    field: 'user.lastName',
-    order: '1',
-  },
-]);
-// If this is a district report, make the schools column first sorted.
-if (props.orgType === 'district') {
-  orderBy.value.unshift({
-    order: '1',
-    field: 'user.schoolName',
-  });
-}
 const filterSchools = ref([]);
 const filterGrades = ref([]);
 const pageLimit = ref(10);
@@ -648,7 +630,7 @@ const computeAssignmentAndRunData = computed(() => {
         // swr: { support_level: 'Needs Extra Support', percentile: 10, raw: 10, reliable: true, engagementFlags: {}},
       };
 
-      let numAssignmentsCompleted = 0;
+      let numAssessmentsCompleted = 0;
       const currRowScores = {};
       for (const assessment of assignment.assessments) {
         // General Logic to grab support level, scores, etc
@@ -667,7 +649,7 @@ const computeAssignmentAndRunData = computed(() => {
         }
         // Add filter tags for completed/incomplete
         if (assessment.completedOn != undefined) {
-          numAssignmentsCompleted += 1;
+          numAssessmentsCompleted += 1;
           scoreFilterTags += ' Completed ';
         } else if (assessment.startedOn != undefined) {
           scoreFilterTags += ' Started ';
@@ -813,13 +795,38 @@ const computeAssignmentAndRunData = computed(() => {
 
       // update scores for current row with computed object
       currRow.scores = currRowScores;
-      currRow.numAssignmentsCompleted = numAssignmentsCompleted;
+      currRow.numAssessmentsCompleted = numAssessmentsCompleted;
       // push currRow to assignmentTableDataAcc
       assignmentTableDataAcc.push(currRow);
     }
 
-    // sort by numAssignmentsCompleted
-    assignmentTableDataAcc.sort((a, b) => b.numAssignmentsCompleted - a.numAssignmentsCompleted);
+    // sort by numAssessmentsCompleted
+    assignmentTableDataAcc.sort((a, b) => {
+      const completionDiff = b.numAssessmentsCompleted - a.numAssessmentsCompleted;
+      if (completionDiff !== 0) {
+        return completionDiff;
+      }
+
+      const schoolDiff = (a.user?.schoolName ?? '').localeCompare(b.user?.schoolName ?? '');
+      if (schoolDiff !== 0) {
+        return schoolDiff;
+      }
+
+      const gradeDiff = Number(a.user.grade) - Number(b.user.grade);
+      if (isNaN(gradeDiff)) {
+        const gradeA = a.user?.grade?.toString() ?? '';
+        const gradeB = b.user?.grade?.toString() ?? '';
+        const stringGradeDiff = gradeA.localeCompare(gradeB);
+        if (stringGradeDiff !== 0) {
+          return stringGradeDiff;
+        }
+      } else if (gradeDiff !== 0) {
+        return gradeDiff;
+      }
+
+      const lastNameDiff = (a.user?.lastName ?? '').localeCompare(b.user?.lastName ?? '');
+      return lastNameDiff;
+    });
 
     const filteredRunsByTaskId = _pickBy(runsByTaskIdAcc, (scores, taskId) => {
       return Object.keys(taskInfoById).includes(taskId);
diff --git a/src/pages/SignIn.vue b/src/pages/SignIn.vue
index ae4baa395..0f0a0e92c 100644
--- a/src/pages/SignIn.vue
+++ b/src/pages/SignIn.vue
@@ -187,11 +187,13 @@ const authWithGoogle = () => {
       .signInWithGooglePopup()
       .then(async () => {
         if (authStore.uid) {
-          const userData = await fetchDocById('users', authStore.uid);
           const userClaims = await fetchDocById('userClaims', authStore.uid);
-          authStore.userData = userData;
           authStore.userClaims = userClaims;
         }
+        if (authStore.roarUid) {
+          const userData = await fetchDocById('users', authStore.roarUid);
+          authStore.userData = userData;
+        }
       })
       .catch((e) => {
         const errorCode = e.code;
@@ -213,9 +215,12 @@ const modalPassword = ref('');
 
 const authWithClever = () => {
   console.log('---> authWithClever');
-  authStore.signInWithCleverRedirect();
+  if (process.env.NODE_ENV === 'development' && !window.Cypress) {
+    authStore.signInWithCleverPopup();
+  } else {
+    authStore.signInWithCleverRedirect();
+  }
   spinner.value = true;
-  // }
 };
 
 const authWithClassLink = () => {
@@ -225,7 +230,6 @@ const authWithClassLink = () => {
     spinner.value = true;
   } else {
     authStore.signInWithClassLinkRedirect();
-    // authStore.signInWithCleverPopup();
     spinner.value = true;
   }
 };
@@ -248,11 +252,13 @@ const authWithEmail = (state) => {
       .logInWithEmailAndPassword(creds)
       .then(async () => {
         if (authStore.uid) {
-          const userData = await fetchDocById('users', authStore.uid);
           const userClaims = await fetchDocById('userClaims', authStore.uid);
-          authStore.userData = userData;
           authStore.userClaims = userClaims;
         }
+        if (authStore.roarUid) {
+          const userData = await fetchDocById('users', authStore.roarUid);
+          authStore.userData = userData;
+        }
 
         spinner.value = true;
       })