diff --git a/packages/app/app/components/RepoSearch.vue b/packages/app/app/components/RepoSearch.vue
index 6b5a971d..a3b13485 100644
--- a/packages/app/app/components/RepoSearch.vue
+++ b/packages/app/app/components/RepoSearch.vue
@@ -1,41 +1,48 @@
 <script lang="ts" setup>
 import type { RepoNode } from "../../server/utils/types";
+
 const search = useSessionStorage("search", "");
 const searchResults = ref<RepoNode[]>([]);
 const isLoading = ref(false);
 
-let activeController: AbortController | null = null;
+let abortController: AbortController | null = null;
 const throttledSearch = useThrottle(search, 500, true, false);
 
 watch(
   throttledSearch,
-  async (newValue) => {
-    activeController?.abort();
+  async (query) => {
+    abortController?.abort();
     searchResults.value = [];
-    if (!newValue) {
+
+    if (!query) {
       isLoading.value = false;
       return;
     }
 
     const controller = new AbortController();
-    activeController = controller;
-
+    abortController = controller;
     isLoading.value = true;
+
     try {
       const response = await fetch(
-        `/api/repo/search?text=${encodeURIComponent(newValue)}`,
-        { signal: activeController.signal },
+        `/api/repo/search?text=${encodeURIComponent(query)}`,
+        { signal: controller.signal },
       );
-      const data = (await response.json()) as { nodes: RepoNode[] };
-      if (activeController === controller) {
-        searchResults.value = data.nodes ?? [];
+      const data = await response.json();
+
+      if (abortController !== controller) {
+        return;
       }
+
+      searchResults.value = Array.isArray(data?.nodes)
+        ? (data.nodes as RepoNode[])
+        : [];
     } catch (err: any) {
       if (err.name !== "AbortError") {
         console.error(err);
       }
     } finally {
-      if (activeController === controller) {
+      if (abortController === controller) {
         isLoading.value = false;
       }
     }
diff --git a/packages/app/server/api/repo/search.get.ts b/packages/app/server/api/repo/search.get.ts
index eb8764dc..19789d89 100644
--- a/packages/app/server/api/repo/search.get.ts
+++ b/packages/app/server/api/repo/search.get.ts
@@ -1,267 +1,182 @@
+import type { H3Event } from "h3";
+import stringSimilarity from "string-similarity";
 import { z } from "zod";
+import { useBucket } from "../../utils/bucket";
 import { useOctokitApp } from "../../utils/octokit";
-import stringSimilarity from "string-similarity";
-import type { RepoNode } from "../../utils/types";
 
 const querySchema = z.object({
   text: z.string(),
 });
 
-interface SearchDebugInfo {
-  startTime: string;
-  endTime: string;
-  totalElapsedMs: number;
-  processedRepositories: number;
-  matchesFound: number;
-  averageProcessingTimePerRepo: number;
-  repositoriesPerSecond: number;
-  searchQuery: string;
-  status: "completed" | "aborted" | "error";
-  flowErrors: Array<{
-    stage: string;
-    error: string;
-    timestamp: string;
-    repositoryContext?: string;
-  }>;
-  flowStages: Array<{
-    stage: string;
-    timestamp: string;
-    details?: string;
-  }>;
+const REPO_INDEX_CACHE_KEY = "repo-search:index";
+const REPO_INDEX_CACHE_TTL_MS = 5 * 60 * 1000;
+
+interface RepoSearchIndexItem {
+  id: number;
+  name: string;
+  ownerLogin: string;
+  ownerAvatarUrl: string;
+  stars: number;
 }
 
-export default defineEventHandler(async (event) => {
-  const request = toWebRequest(event);
-  const signal = request.signal;
+interface RepoSearchIndexCache {
+  fetchedAt: number;
+  repos: RepoSearchIndexItem[];
+}
 
-  const flowErrors: SearchDebugInfo["flowErrors"] = [];
-  const flowStages: SearchDebugInfo["flowStages"] = [];
+type CacheStatus = "hit" | "stale" | "miss";
 
-  const addFlowStage = (stage: string, details?: string) => {
-    flowStages.push({
-      stage,
-      timestamp: new Date().toISOString(),
-      details,
-    });
-  };
+let revalidateRepoIndexPromise: Promise<void> | null = null;
 
-  const addFlowError = (
-    stage: string,
-    error: string,
-    repositoryContext?: string,
-  ) => {
-    flowErrors.push({
-      stage,
-      error,
-      timestamp: new Date().toISOString(),
-      repositoryContext,
-    });
-  };
+async function fetchInstalledRepos(event: H3Event) {
+  const app = useOctokitApp(event);
+  const seen = new Set<number>();
+  const repos: RepoSearchIndexItem[] = [];
 
-  try {
-    addFlowStage("query_validation", "Starting query validation");
+  for await (const { installation } of app.eachInstallation.iterator()) {
+    try {
+      const octokit = await app.getInstallationOctokit(installation.id);
+      const installationRepos = [];
+      for await (const { data } of (octokit as any).paginate.iterator(
+        "GET /installation/repositories",
+        { per_page: 100 },
+      )) {
+        installationRepos.push(
+          ...(Array.isArray(data) ? data : (data.repositories ?? [])),
+        );
+      }
 
-    const query = await getValidatedQuery(event, (data) =>
-      querySchema.parse(data),
-    );
+      for (const repo of installationRepos) {
+        if (repo.private || seen.has(repo.id)) {
+          continue;
+        }
 
-    if (!query.text) {
-      addFlowStage("early_return", "Empty query text");
-      return { nodes: [], debug: null };
+        seen.add(repo.id);
+        repos.push({
+          id: repo.id,
+          name: repo.name,
+          ownerLogin: repo.owner.login,
+          ownerAvatarUrl: repo.owner.avatar_url,
+          stars: repo.stargazers_count || 0,
+        });
+      }
+    } catch {
+      // Skip suspended installations
     }
+  }
 
-    addFlowStage("query_validated", `Query: "${query.text}"`);
+  return repos;
+}
 
-    let app;
-    try {
-      addFlowStage("octokit_init", "Initializing Octokit app");
-      app = useOctokitApp(event);
-      addFlowStage("octokit_ready", "Octokit app initialized successfully");
-    } catch (err: any) {
-      addFlowError("octokit_init", err.message);
-      throw new Error(`Failed to initialize Octokit: ${err.message}`);
-    }
+async function rebuildRepoIndex(event: H3Event) {
+  const bucket = useBucket(event);
+  const repos = await fetchInstalledRepos(event);
 
-    const searchText = query.text.toLowerCase();
-    const matches: RepoNode[] = [];
-    const startTime = Date.now();
-    let processedRepositories = 0;
-    let status: SearchDebugInfo["status"] = "completed";
-    let skippedRepositories = 0;
-    let suspendedErrors = 0;
+  await bucket.setItem(REPO_INDEX_CACHE_KEY, {
+    fetchedAt: Date.now(),
+    repos,
+  });
+}
 
-    addFlowStage(
-      "repository_iteration_start",
-      `Starting to iterate repositories for search: "${searchText}"`,
-    );
+async function revalidateRepoIndex(event: H3Event) {
+  if (revalidateRepoIndexPromise) {
+    return revalidateRepoIndexPromise;
+  }
 
-    try {
-      await app.eachRepository(async ({ repository }) => {
-        try {
-          if (signal.aborted) {
-            addFlowStage(
-              "search_aborted",
-              `Aborted at repository: ${repository.full_name}`,
-            );
-            status = "aborted";
-            return;
-          }
+  revalidateRepoIndexPromise = rebuildRepoIndex(event).finally(() => {
+    revalidateRepoIndexPromise = null;
+  });
+
+  return revalidateRepoIndexPromise;
+}
 
-          if (repository.private) {
-            skippedRepositories++;
-            return;
-          }
+async function getIndexedRepos(event: H3Event): Promise<{
+  repos: RepoSearchIndexItem[];
+  cacheStatus: CacheStatus;
+}> {
+  const bucket = useBucket(event);
+  const now = Date.now();
+  const cached =
+    await bucket.getItem<RepoSearchIndexCache>(REPO_INDEX_CACHE_KEY);
+
+  if (
+    cached &&
+    cached.repos.length > 0 &&
+    now - cached.fetchedAt < REPO_INDEX_CACHE_TTL_MS
+  ) {
+    return { repos: cached.repos, cacheStatus: "hit" };
+  }
 
-          processedRepositories++;
+  if (cached && cached.repos.length > 0) {
+    const refreshPromise = revalidateRepoIndex(event).catch((err) => {
+      console.error("Failed to refresh repo index cache", err);
+    });
 
-          // Add periodic progress tracking
-          if (processedRepositories % 100 === 0) {
-            const elapsed = Date.now() - startTime;
-            addFlowStage(
-              "progress_checkpoint",
-              `Processed ${processedRepositories} repositories in ${elapsed}ms`,
-            );
-          }
+    if (typeof event.waitUntil === "function") {
+      event.waitUntil(refreshPromise);
+    }
 
-          const repoName = repository.name.toLowerCase();
-          const ownerLogin = repository.owner.login.toLowerCase();
+    return { repos: cached.repos, cacheStatus: "stale" };
+  }
 
-          let nameScore, ownerScore;
-          try {
-            nameScore = stringSimilarity.compareTwoStrings(
-              repoName,
-              searchText,
-            );
-            ownerScore = stringSimilarity.compareTwoStrings(
-              ownerLogin,
-              searchText,
-            );
-          } catch (err: any) {
-            addFlowError(
-              "string_similarity",
-              err.message,
-              repository.full_name,
-            );
-            // Use fallback scoring
-            nameScore = repoName.includes(searchText) ? 0.5 : 0;
-            ownerScore = ownerLogin.includes(searchText) ? 0.5 : 0;
-          }
+  const repos = await fetchInstalledRepos(event);
+  await bucket.setItem(REPO_INDEX_CACHE_KEY, {
+    fetchedAt: now,
+    repos,
+  });
 
-          try {
-            matches.push({
-              id: repository.id,
-              name: repository.name,
-              owner: {
-                login: repository.owner.login,
-                avatarUrl: repository.owner.avatar_url,
-              },
-              stars: repository.stargazers_count || 0,
-              score: Math.max(nameScore, ownerScore),
-            });
-          } catch (err: any) {
-            addFlowError("match_creation", err.message, repository.full_name);
-          }
-        } catch (err: any) {
-          if (
-            err.message?.includes("suspended") ||
-            err.message?.includes("Installation")
-          ) {
-            suspendedErrors++;
-            addFlowError(
-              "repository_suspended",
-              err.message,
-              repository.full_name,
-            );
-            return;
-          }
-          addFlowError(
-            "repository_processing",
-            err.message,
-            repository.full_name,
-          );
-          throw err;
-        }
-      });
+  return { repos, cacheStatus: "miss" };
+}
+
+function findMatches(repos: RepoSearchIndexItem[], text: string) {
+  const searchText = text.toLowerCase();
 
-      addFlowStage(
-        "repository_iteration_complete",
-        `Completed repository iteration`,
+  return repos
+    .map((repo) => {
+      const name = repo.name.toLowerCase();
+      const owner = repo.ownerLogin.toLowerCase();
+      const score = Math.max(
+        stringSimilarity.compareTwoStrings(name, searchText),
+        stringSimilarity.compareTwoStrings(owner, searchText),
       );
-    } catch (err: any) {
+
       if (
-        err.message?.includes("suspended") ||
-        err.message?.includes("Installation")
+        score <= 0.3 &&
+        !name.includes(searchText) &&
+        !owner.includes(searchText)
       ) {
-        addFlowError(
-          "iteration_suspended",
-          `Installation suspended after processing ${processedRepositories} repositories: ${err.message}`,
-        );
-        status = "completed";
-      } else {
-        addFlowError("iteration_failed", err.message);
-        status = "error";
-        throw err;
+        return null;
       }
-    }
 
-    const totalElapsed = Date.now() - startTime;
-
-    addFlowStage("sorting_matches", `Sorting ${matches.length} matches`);
-
-    try {
-      matches.sort((a, b) =>
-        b.score !== a.score ? b.score - a.score : b.stars - a.stars,
-      );
-      addFlowStage("sorting_complete", "Matches sorted successfully");
-    } catch (err: any) {
-      addFlowError("sorting", err.message);
-    }
-
-    const top = matches.slice(0, 10).map((node) => ({
-      id: node.id,
-      name: node.name,
-      owner: node.owner,
-      stars: node.stars,
-    }));
+      return {
+        id: repo.id,
+        name: repo.name,
+        owner: {
+          login: repo.ownerLogin,
+          avatarUrl: repo.ownerAvatarUrl,
+        },
+        stars: repo.stars,
+        score,
+      };
+    })
+    .filter((repo): repo is NonNullable<typeof repo> => !!repo)
+    .sort((a, b) => b.score - a.score || b.stars - a.stars)
+    .map(({ score: _score, ...repo }) => repo);
+}
 
-    addFlowStage("response_preparation", `Prepared ${top.length} top results`);
+export default defineEventHandler(async (event) => {
+  const query = await getValidatedQuery(event, (data) =>
+    querySchema.parse(data),
+  );
 
-    const debugInfo: SearchDebugInfo = {
-      startTime: new Date(startTime).toISOString(),
-      endTime: new Date().toISOString(),
-      totalElapsedMs: totalElapsed,
-      processedRepositories,
-      matchesFound: matches.length,
-      averageProcessingTimePerRepo:
-        processedRepositories > 0 ? totalElapsed / processedRepositories : 0,
-      repositoriesPerSecond: processedRepositories / (totalElapsed / 1000),
-      searchQuery: query.text,
-      status,
-      flowErrors,
-      flowStages,
-    };
+  if (!query.text) {
+    return { nodes: [] };
+  }
 
-    return { nodes: top, debug: debugInfo };
-  } catch (error) {
-    addFlowError("global_error", (error as Error).message);
+  const { repos, cacheStatus } = await getIndexedRepos(event);
+  setResponseHeader(event, "x-repo-index-cache", cacheStatus);
 
-    return {
-      nodes: [],
-      error: true,
-      message: (error as Error).message,
-      debug: {
-        startTime: new Date().toISOString(),
-        endTime: new Date().toISOString(),
-        totalElapsedMs: 0,
-        processedRepositories: 0,
-        matchesFound: 0,
-        averageProcessingTimePerRepo: 0,
-        repositoriesPerSecond: 0,
-        searchQuery: "",
-        status: "error" as const,
-        flowErrors,
-        flowStages,
-      },
-    };
-  }
+  return {
+    nodes: findMatches(repos, query.text),
+  };
 });