diff --git a/packages/host/app/components/operator-mode/card-error.gts b/packages/host/app/components/operator-mode/card-error.gts
index 50dfb88de6b..f5992c354ea 100644
--- a/packages/host/app/components/operator-mode/card-error.gts
+++ b/packages/host/app/components/operator-mode/card-error.gts
@@ -4,7 +4,7 @@ import { cached } from '@glimmer/tracking';
 
 import { restartableTask } from 'ember-concurrency';
 
-import { CardHeader } from '@cardstack/boxel-ui/components';
+import { CardHeader, LoadingIndicator } from '@cardstack/boxel-ui/components';
 import type { MenuItem } from '@cardstack/boxel-ui/helpers';
 import { FileAlert, ExclamationCircle } from '@cardstack/boxel-ui/icons';
 
@@ -42,9 +42,16 @@ export default class CardErrorComponent extends Component<Signature> {
   <template>
     {{#unless @hideHeader}}
       <CardHeader
-        class='error-header'
-        @cardTypeDisplayName='Card Error: {{this.errorTitle}}'
-        @cardTypeIcon={{ExclamationCircle}}
+        {{! `error-header` is the structural hook consumers style (e.g. the
+            module inspector stretches it to full width), so it stays on in
+            both states; `pending` only restyles it. }}
+        class='error-header {{if this.isAwaitingIndex "pending"}}'
+        @cardTypeDisplayName={{this.headerDisplayName}}
+        @cardTypeIcon={{if
+          this.isAwaitingIndex
+          LoadingIndicator
+          ExclamationCircle
+        }}
         @isTopCard={{@headerOptions.isTopCard}}
         @moreOptionsMenuItems={{@headerOptions.moreOptionsMenuItems}}
         @onClose={{@headerOptions.onClose}}
@@ -52,40 +59,101 @@ export default class CardErrorComponent extends Component<Signature> {
       />
     {{/unless}}
 
-    <div class='card-error' data-test-card-error={{this.id}}>
-      {{#if this.lastKnownGoodHtml}}
-        <this.lastKnownGoodHtml />
-      {{else}}
-        <div class='card-error-default'>
-          <FileAlert class='icon' />
-          <div class='message'>
-            {{#if @message}}
-              {{@message}}
-            {{else if @cardCreationError}}
-              Failed to create card.
-            {{else}}
-              This card contains an error.
-            {{/if}}
-          </div>
+    {{#if this.isAwaitingIndex}}
+      {{! A live region: the placeholder promises the card will appear on its
+          own, so its arrival has to be announced rather than only drawn. }}
+      <div
+        class='card-pending'
+        role='status'
+        aria-live='polite'
+        data-test-card-awaiting-index={{this.id}}
+      >
+        <LoadingIndicator class='pending-icon' />
+        <div class='pending-message'>
+          <p class='pending-headline'>Preparing this card</p>
+          <p class='pending-detail'>
+            The workspace has the file and is still getting it ready.
+          </p>
         </div>
-      {{/if}}
-    </div>
-    <CardErrorDetail
-      @error={{@error}}
-      @title={{this.errorTitle}}
-      @viewInCodeMode={{@viewInCodeMode}}
-      @fileToFixWithAi={{@fileToFixWithAi}}
-      class='card-error-detail'
-    >
-      <:error>
-        {{yield to='error'}}
-      </:error>
-    </CardErrorDetail>
+      </div>
+    {{else}}
+      <div class='card-error' data-test-card-error={{this.id}}>
+        {{#if this.lastKnownGoodHtml}}
+          <this.lastKnownGoodHtml />
+        {{else}}
+          <div class='card-error-default'>
+            <FileAlert class='icon' />
+            <div class='message'>
+              {{#if @message}}
+                {{@message}}
+              {{else if @cardCreationError}}
+                Failed to create card.
+              {{else}}
+                This card contains an error.
+              {{/if}}
+            </div>
+          </div>
+        {{/if}}
+      </div>
+      <CardErrorDetail
+        @error={{@error}}
+        @title={{this.errorTitle}}
+        @viewInCodeMode={{@viewInCodeMode}}
+        @fileToFixWithAi={{@fileToFixWithAi}}
+        class='card-error-detail'
+      >
+        <:error>
+          {{yield to='error'}}
+        </:error>
+      </CardErrorDetail>
+    {{/if}}
     <style scoped>
       .icon {
         height: 100px;
         width: 100px;
       }
+      .card-pending {
+        display: flex;
+        flex: 1;
+        height: 100%;
+        align-content: center;
+        justify-content: center;
+        flex-wrap: wrap;
+        gap: var(--boxel-sp-xs);
+        padding: var(--boxel-sp);
+      }
+      .pending-icon {
+        --boxel-loading-indicator-size: 60px;
+        color: var(--boxel-400);
+      }
+      .pending-message {
+        width: 100%;
+        text-align: center;
+        text-wrap: pretty;
+      }
+      .pending-headline {
+        margin: 0;
+        font: 600 var(--boxel-font);
+      }
+      .pending-detail {
+        margin: var(--boxel-sp-xxs) auto 0;
+        max-width: 40ch;
+        color: var(--boxel-450);
+        font: var(--boxel-font-sm);
+      }
+      .error-header.pending {
+        min-height: var(--boxel-form-control-height);
+        background-color: var(--boxel-100);
+        box-shadow: 0 1px 0 0 rgba(0 0 0 / 15%);
+      }
+      /* The consumer sets --boxel-card-header-text-color from the realm's own
+         colour — white for a dark realm — which says nothing about the grey
+         painted above. Name a colour that belongs to this background, the way
+         the error state names its own. */
+      .error-header.pending :deep(.card-type-display-name),
+      .error-header.pending :deep(.boxel-loading-indicator) {
+        color: var(--boxel-dark);
+      }
       .card-error-default {
         display: flex;
         height: 100%;
@@ -143,6 +211,22 @@ export default class CardErrorComponent extends Component<Signature> {
     return this.args.error.id;
   }
 
+  // The realm answers a card+json read for an instance whose source it holds
+  // but has not indexed yet with a 404 carrying this marker. Nothing is wrong
+  // with the card — the indexing pass the write kicked off just hasn't landed —
+  // and the store reloads the instance when the realm broadcasts the index
+  // event for it, so this stands in until the real card takes over rather than
+  // reporting a card that isn't there.
+  private get isAwaitingIndex() {
+    return this.args.error.awaitingIndex === true;
+  }
+
+  private get headerDisplayName() {
+    return this.isAwaitingIndex
+      ? 'Preparing Card'
+      : `Card Error: ${this.errorTitle}`;
+  }
+
   private get errorTitle() {
     if (this.args.title) {
       return this.args.title;
diff --git a/packages/host/app/lib/gc-card-store.ts b/packages/host/app/lib/gc-card-store.ts
index 7268e31ef84..dedf429e57a 100644
--- a/packages/host/app/lib/gc-card-store.ts
+++ b/packages/host/app/lib/gc-card-store.ts
@@ -724,6 +724,17 @@ export default class CardStoreWithGarbageCollection implements CardStore {
     return this.getCardItem('error', id);
   }
 
+  // Every card error currently held, as [store key, error] pairs. Reading it
+  // inside an autotracked computation re-runs when an error is added or
+  // removed. The non-tracked bucket is included so a caller sweeping errors
+  // sees the same set `getCardError` would return for each key.
+  cardErrorEntries(): [string, CardErrorJSONAPI][] {
+    return [
+      ...this.#nonTrackedCardInstanceErrors.entries(),
+      ...this.#cardInstanceErrors.entries(),
+    ];
+  }
+
   getFileMetaError(id: string) {
     return this.getFileMetaItem('error', id);
   }
diff --git a/packages/host/app/services/store.ts b/packages/host/app/services/store.ts
index 4937d87f881..7c53a6f87d6 100644
--- a/packages/host/app/services/store.ts
+++ b/packages/host/app/services/store.ts
@@ -2019,15 +2019,21 @@ export default class StoreService extends Service implements StoreInterface {
     };
 
     if (event.indexType === 'full') {
-      // A full reindex carries no per-file invalidation list; report it as a
-      // thin realm-event so the dashboard still sees the pass happened.
+      // A full reindex carries no per-file invalidation list, so there is
+      // nothing to reload by name. A realm that reindexes on request does
+      // broadcast the URLs it visited as an incremental event first, but one
+      // reindexing at startup announces itself with this event alone — so this
+      // can be the only word a card being held as awaiting-index ever gets
+      // that the row it is waiting for now exists.
+      let reloadsTriggered = this.reloadAwaitingIndexInstances(event.realmURL);
+      // Report the pass as a thin realm-event so the dashboard still sees it.
       telemetry?.recordEvent({
         event_type: 'realm-event',
         realm: event.realmURL,
         index_type: 'full',
         invalidations_count: 0,
         invalidated_ids: [],
-        reloads_triggered: 0,
+        reloads_triggered: reloadsTriggered,
         own_write: false,
         processing_ms: 0,
         event_args: eventArgs(),
@@ -2203,6 +2209,20 @@ export default class StoreService extends Service implements StoreInterface {
           this.loadInstanceTask.perform(invalidation);
           reloadsTriggered++;
         }
+      } else if (this.hasInflightCardLoad(invalidation)) {
+        // The invalidation landed while this id's first read was still in
+        // flight, so there is nothing in the store to reload yet. That read
+        // may well be the one that 404s — the index row this event announces
+        // did not exist when it was issued — and its awaiting-index
+        // placeholder would then be stale the moment it is installed, with no
+        // further event coming for it. Reload once the read settles.
+        // Deliberately not counted as a reload: whether one happens depends on
+        // what the read settles into, and the counter is read synchronously
+        // here for the realm-event telemetry.
+        realmEventsLogger.debug(
+          `deferring reload of ${invalidation} until its in-flight load settles`,
+        );
+        this.reloadAfterInflightLoad.perform(invalidation);
       } else {
         realmEventsLogger.debug(
           `ignoring invalidation ${invalidation} because we did not previously try to load it`,
@@ -2256,6 +2276,50 @@ export default class StoreService extends Service implements StoreInterface {
     },
   );
 
+  // Is a first read of `id` still in flight? `inflightGetCards` is keyed by the
+  // normalized URL, which is the form an invalidation carries.
+  private hasInflightCardLoad(id: string): boolean {
+    let url = asURL(id, this.network.virtualNetwork);
+    return url ? this.inflightGetCards.has(url) : false;
+  }
+
+  // Wait out the in-flight read of `id`, then reload it if what it produced was
+  // an awaiting-index placeholder. That placeholder is the store's promise that
+  // the card will appear on its own, and the event that would have kept the
+  // promise is the one already being handled — it arrived too early to find
+  // anything to reload.
+  private reloadAfterInflightLoad = task(async (id: string) => {
+    let url = asURL(id, this.network.virtualNetwork);
+    let inflight = url ? this.inflightGetCards.get(url) : undefined;
+    if (inflight) {
+      await inflight;
+    }
+    if (this.peekError(id)?.awaitingIndex) {
+      this.loadInstanceTask.perform(id);
+    }
+  });
+
+  // Re-read every card being held as awaiting-index in `realmURL`. Their whole
+  // state is "a row for me is coming", and a from-scratch pass is one way it
+  // arrives without any event naming the card.
+  private reloadAwaitingIndexInstances(realmURL: string): number {
+    let reloaded = 0;
+    for (let [id, error] of this.store.cardErrorEntries()) {
+      if (!error.awaitingIndex) {
+        continue;
+      }
+      if (this.realm.realmOf(rri(id)) !== realmURL) {
+        continue;
+      }
+      realmEventsLogger.debug(
+        `reloading ${id} because a full index of ${realmURL} may have landed the row it is waiting for`,
+      );
+      this.loadInstanceTask.perform(id);
+      reloaded++;
+    }
+    return reloaded;
+  }
+
   private reestablishReferences = task(async () => {
     let remoteIds = new Set<string>();
     for (let [id, referenceCount] of this.referenceCount) {
@@ -2381,13 +2445,22 @@ export default class StoreService extends Service implements StoreInterface {
       try {
         maybeReloadedInstance = await this.reloadInstance(instance);
       } catch (err: any) {
-        if (err.status === 404) {
+        let cardError = processCardError(instance.id, err).errors[0];
+        if (cardError?.awaitingIndex) {
+          // The realm holds this card's source and has not indexed it yet.
+          // That is a statement about the index, not about the instance this
+          // tab is already running — so keep it exactly as it is, autosave and
+          // all, and let the index event that follows bring the fresh state.
+          // Treating it as a deletion would evict a card that still exists;
+          // recording it as an error would stand a placeholder in front of one
+          // the user is working in.
+          maybeReloadedInstance = instance;
+        } else if (err.status === 404) {
           // in this case the document was invalidated in the index because the
           // file was deleted
           isDelete = true;
         } else {
-          let errorResponse = processCardError(instance.id, err);
-          maybeReloadedInstance = errorResponse.errors[0];
+          maybeReloadedInstance = cardError;
         }
       }
       // Detach the original instance's autosave subscription when it's been
@@ -2480,6 +2553,22 @@ export default class StoreService extends Service implements StoreInterface {
     if (!instance && !instanceOrError.id) {
       return;
     }
+    // An awaiting-index error says the realm has not caught up with a card it
+    // holds. It is never a statement about a card this tab is already running:
+    // a newly created instance is live in the store under its local id, and
+    // editable there, long before the realm has indexed it. Recording the error
+    // would make `peekError` report it, and every render site reads that to
+    // decide whether to stand a placeholder in front of the card — so a card
+    // the user is working in would be replaced by one. `getCard` correlates a
+    // remote URL back to a locally-created instance, so this holds from the
+    // moment the server assigns an id.
+    if (
+      !instance &&
+      (instanceOrError as CardErrorJSONAPI).awaitingIndex &&
+      this.store.getCard(instanceOrError.id!)
+    ) {
+      return;
+    }
     this.store.addCardInstanceOrError(
       instance ? (instance.id ?? instance[localIdSymbol]) : instanceOrError.id!, // we checked above to make sure errors have id's
       instanceOrError as CardDef | CardErrorJSONAPI,
@@ -2764,6 +2853,15 @@ export default class StoreService extends Service implements StoreInterface {
     } catch (error: any) {
       let errorResponse = processCardError(id, error);
       let cardError = errorResponse.errors[0];
+      // A card this tab is already running outranks the realm's report that it
+      // has not indexed it yet — see `setIdentityContext`. A cache-bypassing
+      // read is the one that gets here with an instance already in hand.
+      let running =
+        cardError?.awaitingIndex && id ? this.store.getCard(id) : undefined;
+      if (running) {
+        deferred?.fulfill(running as T);
+        return running as T;
+      }
       deferred?.fulfill(cardError);
       this.setIdentityContext(cardError);
       let status = cardError?.status ?? error?.status;
diff --git a/packages/host/tests/acceptance/interact-submode/index-changes-test.gts b/packages/host/tests/acceptance/interact-submode/index-changes-test.gts
index 79a44b0a586..63db69020ee 100644
--- a/packages/host/tests/acceptance/interact-submode/index-changes-test.gts
+++ b/packages/host/tests/acceptance/interact-submode/index-changes-test.gts
@@ -7,6 +7,7 @@ import {
   Deferred,
   type LooseSingleCardDocument,
   rri,
+  SupportedMimeType,
 } from '@cardstack/runtime-common';
 import type { Realm } from '@cardstack/runtime-common/realm';
 
@@ -16,6 +17,7 @@ import {
   visitOperatorMode,
 } from '../../helpers';
 import { setupInteractSubmodeTests } from '../../helpers/interact-submode-setup';
+import { getTestRealmRegistry } from '../../helpers/test-realm-registry';
 
 import type {
   IncrementalIndexEventContent,
@@ -36,6 +38,89 @@ module('Acceptance | interact submode | index changes tests', function (hooks) {
     // caches under this module's name, which the outer prefix cannot match.
     setupRealmCacheTeardown(hooks);
 
+    test('a card another client created reads as being prepared, then renders itself once indexing lands', async function (assert) {
+      // Another client's write lands on the realm's file system, with no
+      // indexing pass behind it yet. Writing through the adapter reproduces
+      // that: the bytes are on the realm, and nothing about the card has
+      // passed through this tab — no instance in its store to fall back on,
+      // which is what makes the placeholder the right thing to show.
+      let { adapter } = getTestRealmRegistry().get(testRealmURL)!;
+      let cardURL = `${testRealmURL}Person/late`;
+      await adapter.write(
+        'Person/late.json',
+        JSON.stringify({
+          data: {
+            type: 'card',
+            attributes: { firstName: 'Late' },
+            meta: {
+              adoptsFrom: { module: rri('../person'), name: 'Person' },
+            },
+          },
+        } as LooseSingleCardDocument),
+      );
+
+      // The file event is how this tab finds out an outside write happened —
+      // it is what puts the file in the tree, ahead of any index row for it.
+      getService('message-service').relayRealmEvent({
+        eventName: 'update',
+        added: ['Person/late.json'],
+        realmURL: testRealmURL,
+      });
+      await settled();
+
+      assert.strictEqual(
+        getService('store').peek(cardURL),
+        undefined,
+        'the card never passed through this tab, so nothing of it is in the store',
+      );
+
+      await visitOperatorMode({
+        stacks: [[{ id: cardURL, format: 'isolated' }]],
+      });
+
+      assert
+        .dom('[data-test-card-awaiting-index]')
+        .containsText(
+          'Preparing this card',
+          'the card reads as being prepared rather than missing',
+        );
+      assert
+        .dom('[data-test-card-error]')
+        .doesNotExist('nothing is reported as an error');
+      assert
+        .dom('[data-test-operator-mode-stack="0"] [data-test-person]')
+        .doesNotExist('the card itself has nothing to render yet');
+
+      // Indexing catches up with the file that was already there — the same
+      // bytes, now with a row behind them.
+      let response = await getService('network').authedFetch(
+        `${testRealmURL}_invalidate`,
+        {
+          method: 'POST',
+          headers: {
+            Accept: SupportedMimeType.JSONAPI,
+            'Content-Type': SupportedMimeType.JSONAPI,
+          },
+          body: JSON.stringify({
+            data: { attributes: { urls: [`${testRealmURL}Person/late.json`] } },
+          }),
+        },
+      );
+      assert.strictEqual(
+        response.status,
+        204,
+        'the realm indexed the file that was already on disk',
+      );
+      await settled();
+
+      assert
+        .dom('[data-test-card-awaiting-index]')
+        .doesNotExist('the placeholder gives way on its own');
+      assert
+        .dom('[data-test-operator-mode-stack="0"] [data-test-person]')
+        .hasText('Late', 'the card renders without a reload');
+    });
+
     test('stack item live updates when index changes', async function (assert) {
       await visitOperatorMode({
         stacks: [
diff --git a/packages/host/tests/integration/components/card-error-awaiting-index-test.gts b/packages/host/tests/integration/components/card-error-awaiting-index-test.gts
new file mode 100644
index 00000000000..3181d631c64
--- /dev/null
+++ b/packages/host/tests/integration/components/card-error-awaiting-index-test.gts
@@ -0,0 +1,62 @@
+import type { RenderingTestContext } from '@ember/test-helpers';
+import { render } from '@ember/test-helpers';
+
+import { module, test } from 'qunit';
+
+import CardError from '@cardstack/host/components/operator-mode/card-error';
+import type { CardErrorJSONAPI } from '@cardstack/host/services/store';
+
+import { setupRenderingTest } from '../../helpers/setup';
+
+const CARD_URL = 'https://example.com/realm/Person/just-written';
+
+function cardError(
+  overrides: Partial<CardErrorJSONAPI> = {},
+): CardErrorJSONAPI {
+  return {
+    id: CARD_URL,
+    status: 404,
+    title: 'Not Found',
+    message: `Could not find ${CARD_URL}`,
+    realm: 'https://example.com/realm/',
+    meta: {
+      lastKnownGoodHtml: null,
+      cardTitle: null,
+      scopedCssUrls: [],
+      stack: null,
+    },
+    ...overrides,
+  };
+}
+
+async function renderError(error: CardErrorJSONAPI) {
+  await render(<template><CardError @error={{error}} /></template>);
+}
+
+module('Integration | Component | card-error awaiting index', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('a 404 the realm marked as awaiting indexing renders as work in progress, not as a failure', async function (this: RenderingTestContext, assert) {
+    await renderError(cardError({ awaitingIndex: true }));
+
+    assert
+      .dom(`[data-test-card-awaiting-index="${CARD_URL}"]`)
+      .exists('the pending placeholder stands in for the card')
+      .containsText('Preparing this card');
+    assert.dom('[data-test-card-error]').doesNotExist('no error body is shown');
+    assert
+      .dom('[data-test-error-display]')
+      .doesNotExist('no error detail is offered — nothing has failed');
+  });
+
+  test('a plain 404 still renders as a card error', async function (this: RenderingTestContext, assert) {
+    await renderError(cardError());
+
+    assert
+      .dom(`[data-test-card-error="${CARD_URL}"]`)
+      .exists('the error body is shown');
+    assert
+      .dom('[data-test-card-awaiting-index]')
+      .doesNotExist('nothing suggests the card is on its way');
+  });
+});
diff --git a/packages/host/tests/integration/store-test.gts b/packages/host/tests/integration/store-test.gts
index b43d68f232c..ff7b01ce050 100644
--- a/packages/host/tests/integration/store-test.gts
+++ b/packages/host/tests/integration/store-test.gts
@@ -2877,6 +2877,359 @@ module('Integration | Store', function (hooks) {
       .containsText('Hassan', 'card is still rendered');
   });
 
+  test('a card the realm holds but has not indexed yet shows as being prepared, then renders once indexing lands', async function (assert) {
+    // Writing through the adapter puts the source on the realm without
+    // enqueuing an indexing pass — the state a card+json read sees between a
+    // write landing and the index catching up with it.
+    await testRealmAdapter.write(
+      'Person/pending.json',
+      JSON.stringify({
+        data: {
+          attributes: { name: 'Pending' },
+          meta: {
+            adoptsFrom: { module: testRRI('person'), name: 'Person' },
+          },
+        },
+      } as LooseSingleCardDocument),
+    );
+
+    setCardInOperatorModeState(`${testRealmURL}Person/pending`);
+    await renderComponent(
+      class TestDriver extends GlimmerComponent {
+        <template><OperatorMode @onClose={{noop}} /></template>
+      },
+    );
+
+    await waitFor('[data-test-card-awaiting-index]');
+    assert
+      .dom('[data-test-card-awaiting-index]')
+      .containsText(
+        'Preparing this card',
+        'the card reads as on its way rather than missing',
+      );
+    assert
+      .dom('[data-test-card-error]')
+      .doesNotExist('no card error is reported');
+
+    // The realm indexes the file and broadcasts the invalidation, which is
+    // what the placeholder is waiting on.
+    await testRealm.write(
+      'Person/pending.json',
+      JSON.stringify({
+        data: {
+          attributes: { name: 'Pending Person' },
+          meta: {
+            adoptsFrom: { module: testRRI('person'), name: 'Person' },
+          },
+        },
+      } as LooseSingleCardDocument),
+    );
+
+    await waitFor('[data-test-card-awaiting-index]', { count: 0 });
+    assert
+      .dom(
+        `[data-stack-card="${testRealmURL}Person/pending"] [data-test-field="name"]`,
+      )
+      .containsText(
+        'Pending Person',
+        'the real card takes over once it is indexed',
+      );
+  });
+
+  test('an index event that lands while the first read is in flight still resolves the placeholder', async function (assert) {
+    // The store subscribes to a realm's index events when something first
+    // references a card in it, so give it the same footing the app has by the
+    // time it reads a brand-new card.
+    storeService.addReference(`${testRealmURL}Person/hassan`);
+    await storeService.flush();
+
+    // On the realm's file system, never seen by the index: the read below
+    // comes back as the awaiting-index 404.
+    await testRealmAdapter.write(
+      'Person/racing.json',
+      JSON.stringify({
+        data: {
+          attributes: { name: 'Racing' },
+          meta: {
+            adoptsFrom: { module: testRRI('person'), name: 'Person' },
+          },
+        },
+      } as LooseSingleCardDocument),
+    );
+
+    // Hold that 404 open after the realm has produced it but before the store
+    // records it, so the invalidation below arrives in the gap. Without the
+    // in-flight check the store finds nothing to reload, drops the event, and
+    // then installs a placeholder that no later event ever clears.
+    let cardService = getService('card-service') as any;
+    let originalFetchJSON = cardService.fetchJSON.bind(cardService);
+    let reached404 = new Deferred<void>();
+    let release404 = new Deferred<void>();
+    cardService.fetchJSON = async (url: string | URL, args?: any) => {
+      if (!String(url).includes('Person/racing')) {
+        return originalFetchJSON(url, args);
+      }
+      try {
+        return await originalFetchJSON(url, args);
+      } catch (err) {
+        reached404.fulfill();
+        await release404.promise;
+        throw err;
+      }
+    };
+
+    // Deliver exactly one index event, inside the window. The realm broadcasts
+    // its own when it indexes the file below, and matrix hands that over some
+    // time later — after the read has settled, where the ordinary error-reload
+    // path would pick it up and the window would never be exercised.
+    let messageService = getService('message-service');
+    let deliverRealmEvents =
+      messageService.relayRealmEvent.bind(messageService);
+    messageService.relayRealmEvent = () => {};
+
+    try {
+      let reading = storeService.get(`${testRealmURL}Person/racing`);
+      await reached404.promise;
+
+      await testRealm.write(
+        'Person/racing.json',
+        JSON.stringify({
+          data: {
+            attributes: { name: 'Racing Person' },
+            meta: {
+              adoptsFrom: { module: testRRI('person'), name: 'Person' },
+            },
+          },
+        } as LooseSingleCardDocument),
+      );
+      deliverRealmEvents({
+        eventName: 'index',
+        indexType: 'incremental',
+        invalidations: [`${testRealmURL}Person/racing`],
+        realmURL: testRealmURL,
+      });
+
+      release404.fulfill();
+      await reading;
+      await settled();
+    } finally {
+      // Released here too: if the read never reaches the 404, or the write
+      // throws, the intercepted fetch would otherwise never return and the
+      // test would hang to the qunit timeout instead of failing with a reason.
+      release404.fulfill();
+      delete cardService.fetchJSON;
+      messageService.relayRealmEvent = deliverRealmEvents;
+    }
+
+    let instance = storeService.peek(`${testRealmURL}Person/racing`);
+    assert.true(
+      isCardInstance(instance),
+      'the store holds the card rather than the stale placeholder',
+    );
+    assert.strictEqual(
+      (instance as any).name,
+      'Racing Person',
+      'and it is the indexed state',
+    );
+  });
+
+  test('a full reindex resolves a placeholder even though it names no cards', async function (assert) {
+    // A realm reindexing at startup announces itself with a bare `full` event
+    // and no per-card invalidations, so this is the only word the store gets
+    // that the awaited row now exists.
+    storeService.addReference(`${testRealmURL}Person/hassan`);
+    await storeService.flush();
+
+    await testRealmAdapter.write(
+      'Person/swept.json',
+      JSON.stringify({
+        data: {
+          attributes: { name: 'Swept' },
+          meta: {
+            adoptsFrom: { module: testRRI('person'), name: 'Person' },
+          },
+        },
+      } as LooseSingleCardDocument),
+    );
+
+    let placeholder = await storeService.get(`${testRealmURL}Person/swept`);
+    assert.true(
+      (placeholder as CardErrorJSONAPI).awaitingIndex,
+      'the read leaves an awaiting-index placeholder',
+    );
+
+    // Withhold the realm's own broadcasts so the only event the store sees is
+    // the bare full one handed over below.
+    let messageService = getService('message-service');
+    let deliverRealmEvents =
+      messageService.relayRealmEvent.bind(messageService);
+    messageService.relayRealmEvent = () => {};
+    try {
+      await testRealm.write(
+        'Person/swept.json',
+        JSON.stringify({
+          data: {
+            attributes: { name: 'Swept Person' },
+            meta: {
+              adoptsFrom: { module: testRRI('person'), name: 'Person' },
+            },
+          },
+        } as LooseSingleCardDocument),
+      );
+      deliverRealmEvents({
+        eventName: 'index',
+        indexType: 'full',
+        realmURL: testRealmURL,
+      });
+      await settled();
+    } finally {
+      messageService.relayRealmEvent = deliverRealmEvents;
+    }
+
+    let instance = storeService.peek(`${testRealmURL}Person/swept`);
+    assert.true(
+      isCardInstance(instance),
+      'the sweep replaced the placeholder with the card',
+    );
+    assert.strictEqual(
+      (instance as any).name,
+      'Swept Person',
+      'and it is the indexed state',
+    );
+  });
+
+  test('a reload that 404s while the row is being rebuilt keeps the card instead of deleting it', async function (assert) {
+    let url = `${testRealmURL}Person/rebuilt`;
+    await testRealm.write(
+      'Person/rebuilt.json',
+      JSON.stringify({
+        data: {
+          attributes: { name: 'Rebuilt' },
+          meta: {
+            adoptsFrom: { module: testRRI('person'), name: 'Person' },
+          },
+        },
+      } as LooseSingleCardDocument),
+    );
+    storeService.addReference(url);
+    await storeService.flush();
+    assert.true(
+      isCardInstance(storeService.peek(url)),
+      'the card starts out loaded',
+    );
+
+    // Take the row away and put the file back, without the store hearing
+    // either step — the state a reload meets when the index no longer has a
+    // row but the realm still holds the source.
+    let messageService = getService('message-service');
+    let deliverRealmEvents =
+      messageService.relayRealmEvent.bind(messageService);
+    messageService.relayRealmEvent = () => {};
+    try {
+      await testRealm.delete('Person/rebuilt.json');
+      await testRealmAdapter.write(
+        'Person/rebuilt.json',
+        JSON.stringify({
+          data: {
+            attributes: { name: 'Rebuilt' },
+            meta: {
+              adoptsFrom: { module: testRRI('person'), name: 'Person' },
+            },
+          },
+        } as LooseSingleCardDocument),
+      );
+      deliverRealmEvents({
+        eventName: 'index',
+        indexType: 'incremental',
+        invalidations: [url],
+        realmURL: testRealmURL,
+      });
+      await settled();
+    } finally {
+      messageService.relayRealmEvent = deliverRealmEvents;
+    }
+
+    assert.true(
+      isCardInstance(storeService.peek(url)),
+      'the card is still in the store — nothing was deleted',
+    );
+    assert.strictEqual(
+      storeService.peekError(url),
+      undefined,
+      'and it is left alone rather than covered by a placeholder',
+    );
+  });
+
+  test('a card already running in the store is never displaced by the awaiting-index placeholder', async function (assert) {
+    // A card created in this tab is live under its local id and editable long
+    // before the realm has indexed it. The realm reporting that it has not
+    // caught up says nothing about that instance, and must not put a
+    // placeholder in front of it or detach its autosave.
+    let instance = (await storeService.add(
+      new PersonDef({ name: 'Brand New' }),
+    )) as CardDefType;
+    let url = instance.id!;
+    assert.ok(url, 'the new card was assigned a remote id');
+
+    let messageService = getService('message-service');
+    let deliverRealmEvents =
+      messageService.relayRealmEvent.bind(messageService);
+    messageService.relayRealmEvent = () => {};
+    let cardService = getService('card-service') as any;
+    let originalFetchJSON = cardService.fetchJSON.bind(cardService);
+    // The realm has the file but no row for it yet, so a read of this card
+    // comes back as the awaiting-index 404 while the instance stays live.
+    cardService.fetchJSON = async (fetchUrl: string | URL, args?: any) => {
+      if (String(fetchUrl).includes(url)) {
+        let err = new Error('awaiting index') as any;
+        err.status = 404;
+        err.responseText = JSON.stringify({
+          errors: [
+            {
+              id: url,
+              status: 404,
+              title: 'Not Found',
+              message: `${url} has not finished indexing`,
+              isCardError: true,
+              awaitingIndex: true,
+              additionalErrors: null,
+            },
+          ],
+        });
+        throw err;
+      }
+      return originalFetchJSON(fetchUrl, args);
+    };
+
+    try {
+      deliverRealmEvents({
+        eventName: 'index',
+        indexType: 'incremental',
+        invalidations: [url],
+        realmURL: testRealmURL,
+      });
+      await settled();
+    } finally {
+      delete cardService.fetchJSON;
+      messageService.relayRealmEvent = deliverRealmEvents;
+    }
+
+    assert.strictEqual(
+      storeService.peek(url),
+      instance,
+      'the running instance is still the one the store hands out',
+    );
+    assert.strictEqual(
+      storeService.peekError(url),
+      undefined,
+      'no placeholder stands in front of it',
+    );
+    assert.ok(
+      storeService.getSaveState(url),
+      'and it is still autosaving, so the user can keep editing',
+    );
+  });
+
   test('an instance can be restored after a loader reset', async function (assert) {
     setCardInOperatorModeState(`${testRealmURL}Person/hassan`);
     await renderComponent(
diff --git a/packages/realm-server/tests/card-endpoints-test.ts b/packages/realm-server/tests/card-endpoints-test.ts
index cf31b86bd70..1ff300dabdb 100644
--- a/packages/realm-server/tests/card-endpoints-test.ts
+++ b/packages/realm-server/tests/card-endpoints-test.ts
@@ -920,6 +920,107 @@ module(basename(import.meta.filename), function () {
           assert.ok(response.body.data, 'full body is returned');
           assert.ok(response.get('etag'), '200 response still carries an ETag');
         });
+
+        // A write lands on the realm's file system before it is indexed, so
+        // "no index row" and "no card" are different situations. Writing
+        // straight to disk (rather than through `realm.write`) leaves a file
+        // the index has never seen — the state a client reads during the
+        // window between a write and the indexing pass that follows it, and
+        // the state any replica that did not handle the write is in.
+        module(
+          'card source on disk that the index has never seen',
+          function (hooks) {
+            hooks.beforeEach(function () {
+              let realmDir = join(dir.name, 'realm_server_1', 'test');
+              writeFileSync(
+                join(realmDir, 'unindexed-card.json'),
+                JSON.stringify({
+                  data: {
+                    type: 'card',
+                    attributes: { firstName: 'Pending' },
+                    meta: {
+                      adoptsFrom: { module: './person', name: 'Person' },
+                    },
+                  },
+                }),
+              );
+              // A collection document is a card document but never gets an
+              // instance row of its own, so no amount of waiting makes it
+              // servable.
+              writeFileSync(
+                join(realmDir, 'unindexed-collection.json'),
+                JSON.stringify({ data: [] }),
+              );
+            });
+
+            test('the 404 for a single-card source says it is awaiting indexing rather than missing', async function (assert) {
+              let response = await request
+                .get('/unindexed-card')
+                .set('Accept', 'application/vnd.card+json');
+
+              assert.strictEqual(
+                response.status,
+                404,
+                `HTTP 404 status: ${response.text}`,
+              );
+              assert.true(
+                response.body.errors?.[0]?.awaitingIndex,
+                'the error carries the awaiting-index marker',
+              );
+            });
+
+            test('the conditional-GET path says the same thing', async function (assert) {
+              let response = await request
+                .get('/unindexed-card')
+                .set('Accept', 'application/vnd.card+json')
+                .set('If-None-Match', '"stale-etag"');
+
+              assert.strictEqual(
+                response.status,
+                404,
+                `HTTP 404 status: ${response.text}`,
+              );
+              assert.true(
+                response.body.errors?.[0]?.awaitingIndex,
+                'the error carries the awaiting-index marker',
+              );
+            });
+
+            test('a source the indexer would never give an instance row is a plain 404', async function (assert) {
+              let response = await request
+                .get('/unindexed-collection')
+                .set('Accept', 'application/vnd.card+json');
+
+              assert.strictEqual(
+                response.status,
+                404,
+                `HTTP 404 status: ${response.text}`,
+              );
+              assert.strictEqual(
+                response.body.errors?.[0]?.awaitingIndex,
+                undefined,
+                'nothing suggests a row is coming for it',
+              );
+            });
+          },
+        );
+
+        test('a card with neither an index row nor a source file is a plain 404', async function (assert) {
+          let response = await request
+            .get('/nonexistent-card')
+            .set('Accept', 'application/vnd.card+json');
+
+          assert.strictEqual(
+            response.status,
+            404,
+            `HTTP 404 status: ${response.text}`,
+          );
+          assert.strictEqual(
+            response.body.errors?.[0]?.awaitingIndex,
+            undefined,
+            'nothing suggests the card is on its way',
+          );
+        });
       });
 
       module('published realm', function (hooks) {
diff --git a/packages/runtime-common/error.ts b/packages/runtime-common/error.ts
index 16ae213ebae..c1b6d896136 100644
--- a/packages/runtime-common/error.ts
+++ b/packages/runtime-common/error.ts
@@ -48,6 +48,12 @@ export interface SerializedError {
   // persistently failing visit cannot keep consuming its realm's prerender
   // affinity lane.
   consecutiveVisitFailures?: number;
+  // Set on the 404 a realm returns for an instance whose source file is on
+  // disk but which the index has no row for yet. The reference is sound and
+  // resolves once the indexing pass that the write kicked off lands, so a
+  // consumer holds a placeholder and waits for the realm's index event
+  // instead of committing to a broken reference.
+  awaitingIndex?: true;
 }
 
 // A persisted error document: the `SerializedError` plus the index metadata
@@ -334,6 +340,10 @@ export interface CardErrorJSONAPI {
   title: string;
   message: string;
   realm: string | undefined;
+  // Mirrors `SerializedError['awaitingIndex']`: the realm holds this
+  // instance's source but has not indexed it yet, so this 404 is a wait
+  // rather than an absence.
+  awaitingIndex?: true;
   meta: {
     lastKnownGoodHtml: string | null;
     cardTitle: string | null;
@@ -403,6 +413,9 @@ export function formattedError(
             status.message[cardError.status] ??
             cardError.message,
           realm: error?.responseHeaders?.get('X-Boxel-Realm-Url'),
+          ...(cardError.awaitingIndex || err.awaitingIndex
+            ? { awaitingIndex: true as const }
+            : {}),
           meta:
             meta ??
             (() => {
@@ -448,6 +461,9 @@ export function formattedError(
         title: err?.title ?? status.message[errorStatus] ?? errorMessage,
         message: errorMessage,
         realm: err?.realm ?? error.responseHeaders?.get('X-Boxel-Realm-Url'),
+        ...(err?.awaitingIndex || error?.awaitingIndex
+          ? { awaitingIndex: true as const }
+          : {}),
         meta:
           err?.meta ??
           (() => {
@@ -482,6 +498,7 @@ export class CardError extends Error implements SerializedError {
     | (CardError | SearchResultError['error'] | Error | CardErrorJSONAPI)[]
     | null = null;
   deps?: string[];
+  awaitingIndex?: true;
 
   constructor(
     message: string,
@@ -518,6 +535,9 @@ export class CardError extends Error implements SerializedError {
       id: err.id,
     });
     result.stack = err.stack;
+    if (err.awaitingIndex) {
+      result.awaitingIndex = true;
+    }
     if (err.additionalErrors) {
       result.additionalErrors = err.additionalErrors.map((inner) =>
         CardError.fromSerializableError(inner),
@@ -848,6 +868,21 @@ export function notFound(
   );
 }
 
+// The instance's source file is on the realm but the index — which is what
+// card+json is served from — has no row for it yet. Still a 404, because there
+// is no card document to hand back; the `awaitingIndex` marker is what tells
+// the caller apart from `notFound`, so it can wait for the realm's index event
+// rather than treat the reference as broken.
+export function notIndexedYet(
+  request: Request,
+  requestContext: RequestContext,
+  message = `${request.url} has not finished indexing`,
+): Response {
+  let error = new CardError(message, { status: 404, id: request.url });
+  error.awaitingIndex = true;
+  return responseWithError(error, requestContext);
+}
+
 export function notAcceptable(
   request: Request,
   requestContext: RequestContext,
diff --git a/packages/runtime-common/realm.ts b/packages/runtime-common/realm.ts
index 2452dbd434c..9e7dfd88e19 100644
--- a/packages/runtime-common/realm.ts
+++ b/packages/runtime-common/realm.ts
@@ -77,6 +77,7 @@ import {
 import {
   systemError,
   notFound,
+  notIndexedYet,
   notAcceptable,
   methodNotAllowed,
   badRequest,
@@ -132,6 +133,7 @@ import {
   systemInitiatedPriority,
   userIdFromUsername,
   isCardDocumentString,
+  isSingleCardDocument,
   isBrowserTestEnv,
   unresolveResourceInstanceURLs,
   fileMetaTimestamps,
@@ -5057,6 +5059,47 @@ export class Realm {
     return await this.#adapter.exists(localPath);
   }
 
+  // The index has no row for `localPath`, so there is no card document to
+  // serve. Which 404 that is depends on the source file: a write lands on the
+  // realm's file system first and is indexed after, so a card whose `.json` is
+  // already on disk is one this realm has not caught up with rather than one
+  // that does not exist. `notIndexedYet` says so, letting a caller hold a
+  // placeholder until the realm broadcasts the index event for it. A read
+  // served by the replica that took the write rarely gets here — that path
+  // drains its own in-flight indexing first — but a read served by any other
+  // replica has no such handle on the write.
+  private async missingInstanceResponse(
+    request: Request,
+    requestContext: RequestContext,
+    localPath: LocalPath,
+  ): Promise<Response> {
+    let sourcePath = `${localPath}.json` as LocalPath;
+    if (await this.isIgnored(this.paths.fileURL(sourcePath))) {
+      // An ignored path is never visited, so no amount of waiting produces an
+      // index row for it.
+      return notFound(request, requestContext);
+    }
+    let source = await this.readFileAsText(sourcePath);
+    if (!source) {
+      return notFound(request, requestContext);
+    }
+    // The marker promises an index row is coming, so it has to match what the
+    // indexer will actually make one for: a `.json` whose `data` is a single
+    // card resource. A collection document (which `isCardDocumentString` also
+    // accepts) never becomes an instance row, and neither does anything else
+    // — those are genuinely not cards, not cards in waiting.
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(source.content);
+    } catch {
+      return notFound(request, requestContext);
+    }
+    if (!isSingleCardDocument(parsed)) {
+      return notFound(request, requestContext);
+    }
+    return notIndexedYet(request, requestContext);
+  }
+
   private async fileMetaDocument(
     requestContext: RequestContext,
     localPath: LocalPath,
@@ -5902,7 +5945,11 @@ export class Realm {
             );
             return fileMeta ?? notFound(request, requestContext);
           } else {
-            return notFound(request, requestContext);
+            return await this.missingInstanceResponse(
+              request,
+              requestContext,
+              localPath,
+            );
           }
         }
         if (
@@ -5952,7 +5999,11 @@ export class Realm {
           );
           return fileMeta ?? notFound(request, requestContext);
         } else {
-          return notFound(request, requestContext);
+          return await this.missingInstanceResponse(
+            request,
+            requestContext,
+            localPath,
+          );
         }
       }
       if (maybeError.type === 'error') {