diff --git a/client/src/api.ts b/client/src/api.ts
index 728ef6e00..25098c95e 100644
--- a/client/src/api.ts
+++ b/client/src/api.ts
@@ -47,7 +47,7 @@ import {
   EditAcademyOnlineAccessFormValues,
   CentralIdentityUserLicenseResult,
   CentralIdentityAppLicense,
-  StoreDigitalDeliveryOption, StoreOrderWithStripeSession,
+  StoreDigitalDeliveryOption, StoreOrderWithStripeSession, StoreOrderListItem,
   OrderCharge,
   OrderSession,
   CentralIdentityOrgAdminResult,
@@ -762,7 +762,7 @@ class API {
     query?: string;
   }) {
     const res = await axios.get<
-      ConductorInfiniteScrollResponse<StoreOrderWithStripeSession>
+      ConductorInfiniteScrollResponse<StoreOrderListItem>
     >("/store/admin/orders", {
       params,
     });
diff --git a/client/src/screens/conductor/controlpanel/StoreManager/index.tsx b/client/src/screens/conductor/controlpanel/StoreManager/index.tsx
index 9288222c3..7aa1a1732 100644
--- a/client/src/screens/conductor/controlpanel/StoreManager/index.tsx
+++ b/client/src/screens/conductor/controlpanel/StoreManager/index.tsx
@@ -1,20 +1,22 @@
 import { Link } from "react-router-dom";
-import { Badge, Breadcrumb, Button, Heading, Select, Stack } from "@libretexts/davis-react";
+import { Badge, Breadcrumb, Button, Heading, Input, Select, Stack } from "@libretexts/davis-react";
 import type { BadgeVariant } from "@libretexts/davis-react";
-import { StoreOrderWithStripeSession } from "../../../../types";
+import { StoreOrderListItem } from "../../../../types";
 import useGlobalError from "../../../../components/error/ErrorHooks";
 import SupportCenterTable from "../../../../components/support/SupportCenterTable";
 import { useInfiniteQuery } from "@tanstack/react-query";
 import api from "../../../../api";
 import useDocumentTitle from "../../../../hooks/useDocumentTitle";
+import useDebounce from "../../../../hooks/useDebounce";
 import {
   IconCloudComputing,
   IconDownload,
   IconEye,
+  IconSearch,
 } from "@tabler/icons-react";
 import { useNotifications } from "../../../../context/NotificationContext";
 import { formatPrice, truncateOrderId } from "../../../../utils/storeHelpers";
-import { useState } from "react";
+import { useMemo, useState } from "react";
 
 function luluStatusVariant(status?: string | null): BadgeVariant {
   if (!status) return "default";
@@ -36,12 +38,21 @@ const StoreManager = () => {
   const limit = 25;
   const { addNotification } = useNotifications();
   const { handleGlobalError } = useGlobalError();
+  const { debounce } = useDebounce();
   const [statusFilter, setStatusFilter] = useState("all");
   const [luluStatusFilter, setLuluStatusFilter] = useState("all");
+  const [searchInput, setSearchInput] = useState("");
+  const [searchQuery, setSearchQuery] = useState("");
+
+  // Debounce the value that actually drives the query so each keystroke doesn't refetch.
+  const debouncedSetQuery = useMemo(
+    () => debounce((value: string) => setSearchQuery(value.trim()), 400),
+    []
+  );
 
   const { data, isFetching, isInitialLoading, fetchNextPage } =
     useInfiniteQuery({
-      queryKey: ["store-orders", limit, statusFilter, luluStatusFilter],
+      queryKey: ["store-orders", limit, statusFilter, luluStatusFilter, searchQuery],
       queryFn: async ({ pageParam = null }) => {
         const response = await api.adminGetStoreOrders({
           limit,
@@ -49,6 +60,7 @@ const StoreManager = () => {
           status: statusFilter === "all" ? undefined : statusFilter,
           lulu_status:
             luluStatusFilter === "all" ? undefined : luluStatusFilter,
+          query: searchQuery || undefined,
         });
 
         if (response.data.err) {
@@ -82,7 +94,21 @@ const StoreManager = () => {
       </Stack>
 
       <div className="border border-gray-200 rounded-lg overflow-hidden">
-        <div className="flex items-center gap-4 px-4 py-3 bg-gray-50 border-b border-gray-200">
+        <div className="flex flex-wrap items-end gap-4 px-4 py-3 bg-gray-50 border-b border-gray-200">
+          <div className="grow min-w-[16rem]">
+            <Input
+              name="orderSearch"
+              type="search"
+              label="Search Orders"
+              placeholder="Search by order ID, customer email, or Lulu job ID"
+              value={searchInput}
+              leftIcon={<IconSearch size={16} />}
+              onChange={(e) => {
+                setSearchInput(e.target.value);
+                debouncedSetQuery(e.target.value);
+              }}
+            />
+          </div>
           <Select
             name="luluStatusFilter"
             label="Lulu Job Status"
@@ -113,7 +139,7 @@ const StoreManager = () => {
           />
         </div>
 
-        <SupportCenterTable<StoreOrderWithStripeSession & { actions?: string }>
+        <SupportCenterTable<StoreOrderListItem & { actions?: string }>
           loading={isInitialLoading}
           data={allData || []}
           columns={[
@@ -143,21 +169,21 @@ const StoreManager = () => {
               },
             },
             {
-              accessor: "stripe_session",
+              accessor: "customerEmail",
               title: "Customer Email",
               copyButton: true,
               render(record) {
-                return record.stripe_session?.customer_email || "Unknown";
+                return record.customerEmail || "Unknown";
               },
             },
             {
-              accessor: "stripe_session",
+              accessor: "amountTotal",
               title: "Total Amount",
               render(record) {
                 return (
                   <span>
-                    {record.stripe_session?.amount_total
-                      ? formatPrice(record.stripe_session.amount_total, true)
+                    {record.amountTotal
+                      ? formatPrice(record.amountTotal, true)
                       : "$0.00"}
                   </span>
                 );
diff --git a/client/src/types/Store.ts b/client/src/types/Store.ts
index 7fc4f5c47..fdbdf6568 100644
--- a/client/src/types/Store.ts
+++ b/client/src/types/Store.ts
@@ -124,3 +124,21 @@ export type StoreOrderWithStripeSession = StoreOrder & {
     stripe_session: Stripe.Checkout.Session;
     stripe_charge?: Stripe.Charge | null;
 }
+
+/**
+ * Flat, Stripe-free shape returned by the admin order-list endpoint (served from the
+ * "storeOrders" Meilisearch index). The Store Management table renders these directly —
+ * no live Stripe session is fetched for the list view.
+ */
+export type StoreOrderListItem = {
+    id: string;
+    status: StoreOrder["status"];
+    customerEmail?: string;
+    amountTotal?: number;
+    currency?: string;
+    luluJobID?: string;
+    luluJobStatus?: string;
+    supportTicketUUID?: string;
+    createdAt?: string; // ISO string as stored in the index
+    createdAtTimestamp?: number; // epoch millis
+}
diff --git a/server/api/search-index-management.ts b/server/api/search-index-management.ts
index 0ab9c2672..84a9030ed 100644
--- a/server/api/search-index-management.ts
+++ b/server/api/search-index-management.ts
@@ -6,6 +6,7 @@ import SupportTicketService from "./services/support-ticket-service.js";
 import booksAPI from "./books.js";
 import projectsAPI from "./projects.js";
 import { syncUsersInBackground } from "./services/user-search-service.js";
+import { syncStoreOrdersInBackground } from "./services/store-order-search-service.js";
 
 // Indexes valid for the reinitialize-settings endpoint. Includes search-queries
 // alongside the tuple-typed core indexes.
@@ -190,6 +191,9 @@ async function resyncIndexInBackground(indexName: typeof INDEXES[number]) {
       case "users":
         await syncUsersInBackground();
         break;
+      case "storeOrders":
+        await syncStoreOrdersInBackground();
+        break;
       default:
         throw new Error(`Unknown index: ${indexName}`);
     }
diff --git a/server/api/services/search-service.ts b/server/api/services/search-service.ts
index 895fbe534..0788e2784 100644
--- a/server/api/services/search-service.ts
+++ b/server/api/services/search-service.ts
@@ -4,7 +4,7 @@ import { debugServer, debugError } from "../../debug";
 import Organization from "../../models/organization";
 import { FilterInput, FilterValue } from "../../types";
 
-export const INDEXES = ["books", "projects", "supportTickets", "users"] as const;
+export const INDEXES = ["books", "projects", "supportTickets", "users", "storeOrders"] as const;
 
 // Popular-search-terms index. Kept outside INDEXES so its (different) document shape and
 // looser typing do not leak into addDocuments/search/getIndexStats, which are tuple-typed.
@@ -32,6 +32,7 @@ export const INDEX_PRIMARY_KEYS: Record<(typeof INDEXES)[number], string> = {
   projects: "projectID",
   supportTickets: "uuid",
   users: "uuid",
+  storeOrders: "id",
 };
 
 export const INDEX_FILTERABLE_ATTRIBUTES = {
@@ -39,6 +40,7 @@ export const INDEX_FILTERABLE_ATTRIBUTES = {
   projects: ["status", "classification", "visibility", "orgID"],
   supportTickets: ["queue_id", "status", "priority", "category", "assignedUUIDs"],
   users: ["uuid", "emailDomain"],
+  storeOrders: ["status", "luluJobStatus", "createdAtTimestamp"],
 };
 
 export const INDEX_SORTABLE_ATTRIBUTES = {
@@ -46,13 +48,17 @@ export const INDEX_SORTABLE_ATTRIBUTES = {
   projects: ["status", "classification", "visibility", "orgID"],
   supportTickets: ["status", "category", "timeOpened"],
   users: ["firstName", "lastName"],
+  storeOrders: ["createdAtTimestamp", "amountTotal"],
 };
 
 // Per-index searchable-attribute overrides. Indexes absent from this map use the
 // Meilisearch default (all fields searchable). The users index opts in explicitly so a
 // query can only ever match a name — never the opaque uuid/centralID or the emailDomain.
+// storeOrders opts in explicitly so the single admin search box matches only the order id,
+// customer email, or Lulu job id — never internal fields like error text.
 export const INDEX_SEARCHABLE_ATTRIBUTES: Partial<Record<(typeof INDEXES)[number], string[]>> = {
   users: ["firstName", "lastName"],
+  storeOrders: ["id", "customerEmail", "luluJobID"],
 };
 
 export default class SearchService {
diff --git a/server/api/services/store-order-search-service.ts b/server/api/services/store-order-search-service.ts
new file mode 100644
index 000000000..58f20c701
--- /dev/null
+++ b/server/api/services/store-order-search-service.ts
@@ -0,0 +1,133 @@
+import StoreOrder from "../../models/storeorder.js";
+import SearchService from "./search-service.js";
+import { debugError, debugServer } from "../../debug.js";
+
+/**
+ * Store-order search index ("storeOrders").
+ *
+ * This index backs the superadmin Store Management table. Unlike the "users" index, it
+ * DELIBERATELY contains customer PII (email) and order data, so it MUST NEVER be exposed to
+ * the browser or any client-facing Meilisearch key/tenant token. It is queried exclusively
+ * server-side through the `checkHasRoleMiddleware("libretexts", "superadmin")`-guarded
+ * `/store/admin/orders` endpoint. MongoDB (the StoreOrder collection) is the source of truth;
+ * this index is fully regenerable from it via the admin "Re-sync" button.
+ *
+ * Keeping the index in sync is a nicety, never a critical path: the incremental helpers
+ * (`upsertStoreOrderToSearchIndex` / `removeStoreOrderFromSearchIndex`) swallow and log every
+ * error and MUST be called fire-and-forget so a Meilisearch hiccup can never fail, delay, or
+ * throw into order processing (Stripe webhooks, Lulu webhooks, etc.). `syncStoreOrdersInBackground`
+ * rebuilds the index from scratch.
+ */
+
+// Pipeline stages shared by the full resync and the single-order upsert. The $project shapes
+// the flat index document: only fields the admin table needs, plus a numeric `createdAtTimestamp`
+// that Meilisearch can sort/filter on (Meilisearch cannot sort on ISO Date objects).
+export const storeOrderSearchIndexAggregationStages: any[] = [
+  {
+    $project: {
+      _id: 0,
+      id: 1,
+      status: 1,
+      customerEmail: 1,
+      amountTotal: 1,
+      currency: 1,
+      luluJobID: 1,
+      luluJobStatus: 1,
+      supportTicketUUID: 1,
+      createdAt: 1,
+      // Numeric epoch millis — sortable/filterable in Meilisearch. Falls back to 0 when createdAt
+      // is somehow missing so a document never fails to sort.
+      createdAtTimestamp: { $toLong: { $ifNull: ["$createdAt", new Date(0)] } },
+    },
+  },
+];
+
+/**
+ * Rebuilds the entire storeOrders search index from MongoDB in batches. Used by the admin
+ * "Re-sync" control. Throws on failure so the admin endpoint can surface a meaningful error.
+ */
+export async function syncStoreOrdersInBackground(): Promise<void> {
+  try {
+    debugServer("Initiating Store Orders search index sync...");
+    const searchService = await SearchService.getInstance();
+
+    const batchSize = 500;
+    let skip = 0;
+    let hasMore = true;
+    let totalSynced = 0;
+
+    while (hasMore) {
+      const orders = await StoreOrder.aggregate([
+        { $sort: { _id: 1 } },
+        ...storeOrderSearchIndexAggregationStages,
+        { $skip: skip },
+        { $limit: batchSize },
+      ]);
+
+      if (orders.length === 0) {
+        hasMore = false;
+        break;
+      }
+
+      // Strip ObjectIds/Dates so Meilisearch document validation doesn't choke.
+      const sanitized = JSON.parse(JSON.stringify(orders));
+      await searchService.addDocuments("storeOrders", sanitized);
+      totalSynced += orders.length;
+      debugServer(`Synced batch of ${orders.length} store orders (${totalSynced} total)...`);
+
+      skip += batchSize;
+      if (orders.length < batchSize) {
+        hasMore = false;
+      }
+    }
+
+    debugServer(`Store Orders search index sync completed. Total synced: ${totalSynced}`);
+  } catch (e) {
+    debugError(`Error in syncStoreOrdersInBackground: ${e}`);
+    throw e;
+  }
+}
+
+/**
+ * Upserts a single order into the search index. Best-effort: swallows and logs all errors,
+ * never throws. MUST be called fire-and-forget (do not await in a request/webhook path).
+ *
+ * If the order no longer exists, it is removed instead — keeping the index from going stale.
+ */
+export async function upsertStoreOrderToSearchIndex(id: string): Promise<void> {
+  try {
+    if (!id) return;
+    const searchService = await SearchService.getInstance();
+
+    const results = await StoreOrder.aggregate([
+      { $match: { id } },
+      ...storeOrderSearchIndexAggregationStages,
+    ]);
+
+    const doc = results?.[0];
+    if (!doc) {
+      // No longer exists — make sure it isn't lingering in the index.
+      await searchService.deleteDocuments("storeOrders", [id]);
+      return;
+    }
+
+    const sanitized = JSON.parse(JSON.stringify(doc));
+    await searchService.addDocuments("storeOrders", [sanitized]);
+  } catch (err) {
+    debugError(`[StoreOrderSearchService] Error upserting order ${id} to search index: ${err}`);
+  }
+}
+
+/**
+ * Removes a single order from the search index. Best-effort: swallows and logs all errors,
+ * never throws. MUST be called fire-and-forget (do not await in a request/webhook path).
+ */
+export async function removeStoreOrderFromSearchIndex(id: string): Promise<void> {
+  try {
+    if (!id) return;
+    const searchService = await SearchService.getInstance();
+    await searchService.deleteDocuments("storeOrders", [id]);
+  } catch (err) {
+    debugError(`[StoreOrderSearchService] Error removing order ${id} from search index: ${err}`);
+  }
+}
diff --git a/server/api/services/store-service.ts b/server/api/services/store-service.ts
index 409237398..40ccbceb8 100644
--- a/server/api/services/store-service.ts
+++ b/server/api/services/store-service.ts
@@ -17,7 +17,10 @@ import mailAPI from "../mail"
 import User from "../../models/user";
 import authAPI from "../../api/auth.js";
 import SupportTicketService from "./support-ticket-service";
-import { escapeRegExp } from "es-toolkit/string";
+import SearchService from "./search-service.js";
+import { upsertStoreOrderToSearchIndex } from "./store-order-search-service.js";
+import { FilterObject } from "../../types/Search.js";
+import { StoreOrderListItem } from "../../types/Store.js";
 
 const BASE_COST = 1.80;
 const PAGE_MULTIPLIER = 0.032;
@@ -703,7 +706,10 @@ class StoreService {
                     throw new Error("MISSING_EMAIL");
                 }
                 storeOrder.customerEmail = email;
-                await storeOrder.save(); // Save the email to the order now in case processing fails later
+                // Mirror the order total from Stripe so the admin list never needs a live Stripe call.
+                storeOrder.amountTotal = checkout_session.amount_total ?? undefined;
+                storeOrder.currency = checkout_session.currency ?? undefined;
+                await storeOrder.save(); // Save the email/amount to the order now in case processing fails later
 
                 const lineItems = this._parseLineItemsFromCheckoutSession(checkout_session);
                 if (!lineItems || lineItems.length === 0) {
@@ -779,6 +785,9 @@ class StoreService {
                     await mailAPI.sendStoreOrderConfirmation(checkout_session.customer_details?.email, checkout_session.id)
                 }
 
+                // Best-effort: mirror the finished order into the search index. Fire-and-forget so a
+                // Meilisearch hiccup can never affect order processing.
+                void upsertStoreOrderToSearchIndex(storeOrder.id);
                 return storeOrder;
             } catch (error: any) {
                 await this._failStoreOrder(storeOrder, error.toString());
@@ -855,6 +864,9 @@ class StoreService {
             storeOrder.luluJobStatusMessage = data.status?.message || "";
             storeOrder.luluJobStatusUpdates = [...(storeOrder.luluJobStatusUpdates || []), data];
             await storeOrder.save();
+
+            // Best-effort: keep the search index in step with the new Lulu status (fire-and-forget).
+            void upsertStoreOrderToSearchIndex(storeOrder.id);
         } catch (error) {
             debug("Error processing Lulu order update:", error);
         }
@@ -923,6 +935,8 @@ class StoreService {
             store_order.luluJobStatusMessage = printJob.status["message"] || "";
             await store_order.save();
 
+            // Best-effort: reflect the resubmitted Lulu job in the search index (fire-and-forget).
+            void upsertStoreOrderToSearchIndex(store_order.id);
             return printJob;
         } catch (error) {
             debug("Error retrying Lulu job:", error);
@@ -932,7 +946,7 @@ class StoreService {
     }
 
     public async adminGetStoreOrders(params: z.infer<typeof AdminGetStoreOrdersSchema>['query']): Promise<{
-        items: StoreOrderWithStripeSession[];
+        items: StoreOrderListItem[];
         meta: {
             total_count: number;
             has_more: boolean;
@@ -940,59 +954,39 @@ class StoreService {
         };
     }> {
         try {
-            let limit = params?.limit ? parseInt(params.limit.toString(), 10) : 25;
-            let filter: any = { $and: [] };
-
-            const trimmedQuery = params?.query?.trim();
-
-            if (params?.starting_after) {
-                // ensure mongoID is properly formatted
-                filter.$and.push({ _id: { $lt: params.starting_after } });
-            }
-            if (params?.status) {
-                filter.$and.push({ status: params?.status });
-            }
-            if (params?.lulu_status) {
-                filter.$and.push({ luluJobStatus: params?.lulu_status });
-            }
-            if (trimmedQuery && trimmedQuery.length > 0) {
-                filter.$and.push(
-                    { id: new RegExp(escapeRegExp(trimmedQuery), 'i') },
-                );
-            }
-
-            const orders = await StoreOrder.find(filter).sort({ _id: -1 }).limit(limit).exec();
-            if (!orders || orders.length === 0) {
-                return {
-                    items: [],
-                    meta: {
-                        total_count: 0,
-                        has_more: false,
-                        next_page: null
-                    }
-                };
-            }
+            const limit = params?.limit ? parseInt(params.limit.toString(), 10) : 25;
+            // `starting_after` carries the Meilisearch offset for the next page (as a string).
+            const offset = params?.starting_after ? Math.max(parseInt(params.starting_after, 10) || 0, 0) : 0;
+            const query = params?.query?.trim() || "";
+
+            // Retain the two existing filters, translated to the storeOrders index attributes.
+            const filters: FilterObject = {};
+            if (params?.status) filters.status = params.status;
+            if (params?.lulu_status) filters.luluJobStatus = params.lulu_status;
+            const hasFilters = Object.keys(filters).length > 0;
+
+            const searchService = await SearchService.getInstance();
+            const result: any = await searchService.search(
+                "storeOrders",
+                query,
+                hasFilters ? filters : undefined,
+                // With a text query, let Meilisearch rank by relevance; otherwise show newest first.
+                query ? undefined : [{ field: "createdAtTimestamp", order: "desc" }],
+                { offset, limit },
+            );
+
+            const items: StoreOrderListItem[] = result?.hits || [];
+            const total_count = result?.estimatedTotalHits ?? items.length;
+            const nextOffset = offset + items.length;
+            const has_more = nextOffset < total_count;
 
-            const order_data: StoreOrderWithStripeSession[] = [];
-            for (const order of orders) {
-                const { session } = await this._fetchCheckoutSession(order.id);
-                order_data.push({
-                    ...order.toObject(), // Convert Mongoose document to plain object
-                    stripe_session: session
-                });
-            }
-
-            const total_count = await StoreOrder.countDocuments(filter);
-            const previously_fetched_count = params?.starting_after ? await StoreOrder.countDocuments({ _id: { $gt: params.starting_after } }) : 0;
-            const has_more = total_count > (previously_fetched_count + orders.length);
-            const next_page = (orders.length === limit ? orders[orders.length - 1]._id?.toString() : null) || null;
             return {
-                items: order_data,
+                items,
                 meta: {
                     total_count,
                     has_more,
-                    next_page
-                }
+                    next_page: has_more ? nextOffset.toString() : null,
+                },
             };
         } catch (error) {
             debug("Error fetching store orders:", error);
@@ -1626,6 +1620,8 @@ class StoreService {
             message: error,
         });
 
+        // Best-effort: reflect the failed status in the search index (fire-and-forget).
+        void upsertStoreOrderToSearchIndex(storeOrder.id);
         return result;
     }
 
diff --git a/server/migrations/BackfillStoreOrderAmounts.ts b/server/migrations/BackfillStoreOrderAmounts.ts
new file mode 100644
index 000000000..e9894e5b9
--- /dev/null
+++ b/server/migrations/BackfillStoreOrderAmounts.ts
@@ -0,0 +1,100 @@
+import mongoose from "mongoose";
+import StoreOrder from "../models/storeorder.js";
+import StripeService from "../api/services/stripe-service.js";
+// import dotenv from "dotenv";
+// dotenv.config();
+
+/**
+ * Backfills `amountTotal`/`currency` (and `customerEmail` when missing) onto historical
+ * StoreOrder documents from their Stripe checkout session.
+ *
+ * These fields are now persisted at order-processing time and mirrored into the "storeOrders"
+ * Meilisearch index so the admin Store Management table never needs a live Stripe call. Orders
+ * created before that change have no `amountTotal`, so this one-time pass fetches each missing
+ * value from Stripe. Run once, then trigger a "storeOrders" re-sync from the ControlPanel
+ * search-index page.
+ *
+ * Idempotent: it only touches documents still missing `amountTotal`, and skips any order whose
+ * Stripe session can't be retrieved (logged, left for a later run).
+ */
+
+export async function runMigration() {
+  try {
+    if (!process.env.MONGOOSEURI) {
+      throw new Error("MONGOOSEURI environment variable is not set.");
+    }
+    if (!process.env.STRIPE_SECRET_KEY) {
+      throw new Error("STRIPE_SECRET_KEY environment variable is not set.");
+    }
+
+    await mongoose.connect(process.env.MONGOOSEURI, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+    } as mongoose.ConnectOptions);
+    console.log("Connected to MongoDB.");
+
+    const stripeService = new StripeService();
+
+    const orders = await StoreOrder.find({
+      $or: [{ amountTotal: { $exists: false } }, { amountTotal: null }],
+    }).lean();
+
+    console.log(`Found ${orders.length} store order(s) missing amountTotal.`);
+
+    let updated = 0;
+    let skipped = 0;
+
+    // Sequential to stay well within Stripe rate limits; historical volume is small.
+    for (const order of orders) {
+      try {
+        const session = await stripeService.getExpandedCheckoutSession(order.id);
+        if (!session) {
+          console.warn(`No Stripe session for order ${order.id}; skipping.`);
+          skipped += 1;
+          continue;
+        }
+
+        const update: Record<string, unknown> = {};
+        if (session.amount_total !== null && session.amount_total !== undefined) {
+          update.amountTotal = session.amount_total;
+        }
+        if (session.currency) {
+          update.currency = session.currency;
+        }
+        // Repair a missing customerEmail while we already hold the session.
+        if (!order.customerEmail) {
+          const email = session.customer_details?.email || session.customer_email;
+          if (email) update.customerEmail = email;
+        }
+
+        if (Object.keys(update).length === 0) {
+          skipped += 1;
+          continue;
+        }
+
+        await StoreOrder.updateOne({ _id: order._id }, { $set: update });
+        updated += 1;
+      } catch (err) {
+        console.warn(`Error backfilling order ${order.id}:`, err);
+        skipped += 1;
+      }
+    }
+
+    console.log(
+      `Store order amount backfill complete. Updated: ${updated}, skipped: ${skipped}.`
+    );
+    console.log(
+      'Next step: trigger a "storeOrders" re-sync from the ControlPanel search-index page.'
+    );
+  } catch (err) {
+    console.error("Error during migration: ", err);
+    throw err;
+  } finally {
+    await mongoose.disconnect();
+  }
+}
+
+// Uncomment to run standalone (from server/): npx tsx migrations/BackfillStoreOrderAmounts.ts
+// runMigration()
+//   .then(() => process.exit(0))
+//   .catch(() => process.exit(1));
diff --git a/server/models/storeorder.ts b/server/models/storeorder.ts
index c958da881..57bc2a0ca 100644
--- a/server/models/storeorder.ts
+++ b/server/models/storeorder.ts
@@ -13,6 +13,8 @@ export interface RawStoreOrder {
     status: "pending" | "completed" | "failed" | "canceled";
     error: string; // Error message if the order fails
     customerEmail?: string; // Marked optional for backwards compatibility, but should be set when creating a new order
+    amountTotal?: number; // Order total in the smallest currency unit (e.g. cents), mirrored from the Stripe checkout session so the admin list never needs a live Stripe call
+    currency?: string; // ISO currency code for amountTotal (e.g. "usd")
     luluJobID?: string;
     luluJobStatus?: string;
     luluJobStatusMessage?: string; // Error message if the Lulu job fails
@@ -44,6 +46,8 @@ const StoreOrderSchema = new Schema<RawStoreOrder>({
         default: "pending",
     },
     customerEmail: String, // Optional for backwards compatibility, but should be set when creating a new order
+    amountTotal: Number, // Smallest currency unit (e.g. cents), mirrored from the Stripe checkout session
+    currency: String, // ISO currency code for amountTotal (e.g. "usd")
     error: String,
     luluJobID: String,
     luluJobStatus: String,
diff --git a/server/types/Store.ts b/server/types/Store.ts
index 7f4bab6ae..1e0ee734a 100644
--- a/server/types/Store.ts
+++ b/server/types/Store.ts
@@ -57,4 +57,22 @@ export type ResolvedProduct = {
 export type StoreOrderWithStripeSession = Prettify<RawStoreOrder & {
     stripe_session: Stripe.Checkout.Session | null;
     stripe_charge?: Stripe.Charge | null
-}>
\ No newline at end of file
+}>
+
+/**
+ * Flat, Stripe-free shape of a store order as returned by the admin list endpoint
+ * (served from the "storeOrders" Meilisearch index). Contains only what the Store
+ * Management table renders — no live Stripe session is fetched for the list view.
+ */
+export type StoreOrderListItem = {
+    id: string;
+    status: RawStoreOrder["status"];
+    customerEmail?: string;
+    amountTotal?: number;
+    currency?: string;
+    luluJobID?: string;
+    luluJobStatus?: string;
+    supportTicketUUID?: string;
+    createdAt?: string; // ISO string as stored in the index
+    createdAtTimestamp?: number; // epoch millis (sortable in Meilisearch)
+}
\ No newline at end of file