diff --git a/packages/hoppscotch-common/locales/en.json b/packages/hoppscotch-common/locales/en.json
index c99c86bd680..aaec37eb7e3 100644
--- a/packages/hoppscotch-common/locales/en.json
+++ b/packages/hoppscotch-common/locales/en.json
@@ -1943,7 +1943,21 @@
     "invalid_json" : "Invalid JSON file format",
     "dataset_iterations_info" : "Dataset contains {rows} rows, running {total} iterations as per your configuration.",
     "dataset_iterations_exceeds" : "Dataset contains {rows} rows, but {extra} iterations will be run as per your configuration.",
-    "no_failed_tests": "No tests failed"
+    "no_failed_tests": "No tests failed",
+    "request_selection": "Request Selection",
+    "select_requests": "Select Requests to Run",
+    "select_all": "Select All",
+    "deselect_all": "Deselect All",
+    "run_selected": "Run Selected",
+    "all_requests_selected": "All requests selected",
+    "expand_modal": "Expand",
+    "collapse_modal": "Collapse",
+    "loading_requests": "Loading requests...",
+    "select_tab": "Select",
+    "order_tab": "Order",
+    "drag_to_reorder": "Drag to reorder",
+    "will_run": "will run",
+    "reset_order": "Reset"
   },
   "ai_experiments": {
     "generate_request_name": "Generate Request Name Using AI",
diff --git a/packages/hoppscotch-common/src/components.d.ts b/packages/hoppscotch-common/src/components.d.ts
index d0329b81c8d..8b6a2cea7b7 100644
--- a/packages/hoppscotch-common/src/components.d.ts
+++ b/packages/hoppscotch-common/src/components.d.ts
@@ -216,6 +216,9 @@ declare module 'vue' {
     HttpTestEnv: typeof import('./components/http/test/Env.vue')['default']
     HttpTestFolder: typeof import('./components/http/test/Folder.vue')['default']
     HttpTestRequest: typeof import('./components/http/test/Request.vue')['default']
+    HttpTestRequestRunOrder: typeof import('./components/http/test/RequestRunOrder.vue')['default']
+    HttpTestRequestSelectionTree: typeof import('./components/http/test/RequestSelectionTree.vue')['default']
+    HttpTestRequestSelectionTreeNode: typeof import('./components/http/test/RequestSelectionTreeNode.vue')['default']
     HttpTestResponse: typeof import('./components/http/test/Response.vue')['default']
     HttpTestResult: typeof import('./components/http/TestResult.vue')['default']
     HttpTestResultEntry: typeof import('./components/http/TestResultEntry.vue')['default']
diff --git a/packages/hoppscotch-common/src/components/http/test/RequestRunOrder.vue b/packages/hoppscotch-common/src/components/http/test/RequestRunOrder.vue
new file mode 100644
index 00000000000..5897afd4566
--- /dev/null
+++ b/packages/hoppscotch-common/src/components/http/test/RequestRunOrder.vue
@@ -0,0 +1,269 @@
+<template>
+  <div class="flex flex-col h-full">
+    <!-- Header: title + Select All / Deselect All / Reset -->
+    <div
+      class="flex items-center justify-between pb-2 mb-2 border-b border-divider flex-shrink-0"
+    >
+      <span class="text-xs font-semibold text-secondaryDark">
+        {{ t("collection_runner.request_selection") }}
+        <span class="ml-1 font-normal text-secondaryLight">
+          ({{ selectedCount }}/{{ items.length }})
+        </span>
+      </span>
+      <div class="flex items-center gap-2 text-xs text-secondaryLight">
+        <button
+          class="hover:text-secondary transition-colors"
+          @click="deselectAll"
+        >
+          {{ t("collection_runner.deselect_all") }}
+        </button>
+        <span class="opacity-30">|</span>
+        <button
+          class="hover:text-secondary transition-colors"
+          @click="selectAll"
+        >
+          {{ t("collection_runner.select_all") }}
+        </button>
+        <span class="opacity-30">|</span>
+        <button
+          class="hover:text-secondary transition-colors"
+          @click="resetOrder"
+        >
+          {{ t("collection_runner.reset_order") }}
+        </button>
+      </div>
+    </div>
+
+    <!-- Draggable list -->
+    <draggable
+      v-model="items"
+      class="flex-1 overflow-y-auto space-y-0.5"
+      :item-key="(item: FlatRequest) => item.path"
+      animation="200"
+      handle=".drag-handle"
+      draggable=".drag-item"
+      ghost-class="opacity-40"
+      chosen-class="bg-primaryLight"
+      drag-class="cursor-grabbing"
+    >
+      <template #item="{ element: item }">
+        <div
+          class="drag-item flex items-center gap-2 p-2 rounded hover:bg-primaryLight group"
+        >
+          <!-- Drag handle: must be a real DOM element (not SVG) for Sortable.js -->
+          <HoppButtonSecondary
+            :icon="IconGripVertical"
+            class="drag-handle cursor-grab opacity-30 group-hover:opacity-100 flex-shrink-0"
+            tabindex="-1"
+          />
+
+          <!-- Checkbox -->
+          <HoppSmartCheckbox
+            :on="isSelected(item.path)"
+            @change="toggleSelection(item.path)"
+          />
+
+          <!-- Method badge -->
+          <span
+            class="text-xs font-medium flex-shrink-0 px-1.5 py-0.5 rounded min-w-[3.5rem] text-center uppercase"
+            :class="methodClass(item.method)"
+          >
+            {{ item.method }}
+          </span>
+
+          <!-- Request name + folder breadcrumb -->
+          <div class="flex flex-col min-w-0 flex-1">
+            <span class="text-secondaryDark text-sm truncate">
+              {{ item.name }}
+            </span>
+            <span
+              v-if="item.folderPath.length > 0"
+              class="text-xs text-secondaryLight truncate"
+            >
+              {{ item.folderPath.join(" › ") }}
+            </span>
+          </div>
+        </div>
+      </template>
+    </draggable>
+
+    <div
+      v-if="items.length === 0"
+      class="flex items-center justify-center h-32 text-secondaryLight text-sm"
+    >
+      {{ t("collection_runner.loading_requests") }}
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { HoppCollection, HoppRESTRequest } from "@hoppscotch/data"
+import { computed, PropType, ref, watch } from "vue"
+import draggable from "vuedraggable-es"
+import { useI18n } from "~/composables/i18n"
+import { RequestSelectionState } from "./RequestSelectionTree.vue"
+import IconGripVertical from "~icons/lucide/grip-vertical"
+
+const t = useI18n()
+
+type FlatRequest = {
+  path: string
+  name: string
+  method: string
+  folderPath: string[]
+}
+
+const props = defineProps({
+  collection: {
+    type: Object as PropType<HoppCollection>,
+    required: true,
+  },
+  modelValue: {
+    type: Array as PropType<string[]>,
+    default: () => [],
+  },
+  selection: {
+    type: Object as PropType<RequestSelectionState>,
+    default: () => ({}),
+  },
+})
+
+const emit = defineEmits<{
+  (e: "update:modelValue", value: string[]): void
+  (e: "update:selection", value: RequestSelectionState): void
+}>()
+
+/**
+ * Flatten the collection into an ordered array of FlatRequest items.
+ * Traversal order: folders first, then requests (matching the runner's natural order).
+ */
+const flattenCollection = (collection: HoppCollection): FlatRequest[] => {
+  const result: FlatRequest[] = []
+
+  const traverse = (
+    node: HoppCollection,
+    parentPath: string,
+    folderNames: string[]
+  ) => {
+    // Process folders first (matches runner's traversal order)
+    node.folders.forEach((folder, folderIdx) => {
+      const folderSegment = parentPath
+        ? `${parentPath}/folder_${folderIdx}`
+        : `folder_${folderIdx}`
+      traverse(folder as HoppCollection, folderSegment, [
+        ...folderNames,
+        folder.name,
+      ])
+    })
+
+    // Then requests
+    node.requests.forEach((request, reqIdx) => {
+      const reqPath = parentPath
+        ? `${parentPath}/request_${reqIdx}`
+        : `request_${reqIdx}`
+      result.push({
+        path: reqPath,
+        name: request.name,
+        method: (request as HoppRESTRequest).method || "GET",
+        folderPath: folderNames,
+      })
+    })
+  }
+
+  traverse(collection, "", [])
+  return result
+}
+
+/**
+ * Build the items list respecting the provided model order.
+ * If modelValue has paths, use that order; otherwise use natural order.
+ * Any new paths not in modelValue are appended at the end.
+ */
+const buildItemsFromOrder = (): FlatRequest[] => {
+  const allItems = flattenCollection(props.collection)
+  const allItemMap = new Map(allItems.map((item) => [item.path, item]))
+
+  if (props.modelValue.length > 0) {
+    const ordered: FlatRequest[] = []
+
+    for (const path of props.modelValue) {
+      const item = allItemMap.get(path)
+      if (item) ordered.push(item)
+    }
+
+    // Append any new items not yet in the order
+    for (const item of allItems) {
+      if (!props.modelValue.includes(item.path)) {
+        ordered.push(item)
+      }
+    }
+
+    return ordered
+  }
+
+  return allItems
+}
+
+const items = ref<FlatRequest[]>(buildItemsFromOrder())
+
+// Rebuild when collection changes (e.g., collection reloads)
+watch(
+  () => props.collection,
+  () => {
+    items.value = buildItemsFromOrder()
+  },
+  { deep: true }
+)
+
+// Emit order changes when items are reordered via drag-and-drop
+watch(
+  items,
+  () => {
+    emit(
+      "update:modelValue",
+      items.value.map((item) => item.path)
+    )
+  },
+  { deep: true }
+)
+
+const isSelected = (path: string): boolean => props.selection[path] ?? false
+
+const toggleSelection = (path: string) => {
+  emit("update:selection", {
+    ...props.selection,
+    [path]: !props.selection[path],
+  })
+}
+
+const selectAll = () => {
+  const newState: RequestSelectionState = {}
+  items.value.forEach((item) => { newState[item.path] = true })
+  emit("update:selection", newState)
+}
+
+const deselectAll = () => {
+  const newState: RequestSelectionState = {}
+  items.value.forEach((item) => { newState[item.path] = false })
+  emit("update:selection", newState)
+}
+
+const resetOrder = () => {
+  items.value = flattenCollection(props.collection)
+}
+
+const selectedCount = computed(
+  () => items.value.filter((item) => isSelected(item.path)).length
+)
+
+const methodClass = (method: string): string => {
+  const m = (method || "GET").toUpperCase()
+  if (m === "GET") return "bg-green-500/10 text-green-500"
+  if (m === "POST") return "bg-yellow-500/10 text-yellow-500"
+  if (m === "PUT") return "bg-blue-500/10 text-blue-500"
+  if (m === "DELETE") return "bg-red-500/10 text-red-500"
+  if (m === "PATCH") return "bg-orange-500/10 text-orange-500"
+  if (m === "HEAD") return "bg-purple-500/10 text-purple-500"
+  return "bg-gray-500/10 text-gray-500"
+}
+</script>
diff --git a/packages/hoppscotch-common/src/components/http/test/RequestSelectionTree.vue b/packages/hoppscotch-common/src/components/http/test/RequestSelectionTree.vue
new file mode 100644
index 00000000000..277637eca27
--- /dev/null
+++ b/packages/hoppscotch-common/src/components/http/test/RequestSelectionTree.vue
@@ -0,0 +1,161 @@
+<template>
+  <div class="flex flex-col space-y-2">
+    <!-- Select All / Deselect All Controls -->
+    <div class="flex items-center justify-between pb-2 border-b border-divider">
+      <div class="flex items-center gap-2">
+        <HoppSmartCheckbox :on="allSelected" @change="toggleSelectAll">
+          <span class="font-semibold text-secondaryDark">
+            {{ t("collection_runner.select_requests") }}
+          </span>
+        </HoppSmartCheckbox>
+        <span class="text-xs text-secondaryLight">
+          {{ selectedCount }} / {{ totalCount }}
+          {{ totalCount === 1 ? t("count.request") : t("count.requests") }}
+        </span>
+      </div>
+      <div class="flex gap-2">
+        <HoppButtonSecondary
+          v-if="!allSelected"
+          :label="t('collection_runner.select_all')"
+          outline
+          @click="selectAll"
+        />
+        <HoppButtonSecondary
+          v-if="selectedCount > 0"
+          :label="t('collection_runner.deselect_all')"
+          outline
+          @click="deselectAll"
+        />
+      </div>
+    </div>
+
+    <!-- Collection Tree -->
+    <div class="flex-1 overflow-auto space-y-1">
+      <RequestSelectionTreeNode
+        :collection="collection"
+        :selection-state="selectionState"
+        :path="[]"
+        @toggle="toggleSelection"
+      />
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { HoppCollection } from "@hoppscotch/data"
+import { computed, PropType, ref } from "vue"
+import { useI18n } from "~/composables/i18n"
+import RequestSelectionTreeNode from "./RequestSelectionTreeNode.vue"
+
+const t = useI18n()
+
+export type RequestSelectionState = {
+  [path: string]: boolean
+}
+
+const props = defineProps({
+  collection: {
+    type: Object as PropType<HoppCollection>,
+    required: true,
+  },
+  modelValue: {
+    type: Object as PropType<RequestSelectionState>,
+    default: () => ({}),
+  },
+})
+
+const emit = defineEmits<{
+  (e: "update:modelValue", value: RequestSelectionState): void
+}>()
+
+const buildAllPaths = (
+  collection: HoppCollection,
+  parentPath: string = ""
+): string[] => {
+  const paths: string[] = []
+
+  collection.requests.forEach((_: any, idx: number) => {
+    const path = parentPath ? `${parentPath}/request_${idx}` : `request_${idx}`
+    paths.push(path)
+  })
+
+  collection.folders.forEach((folder: any, folderIdx: number) => {
+    const folderPath = parentPath
+      ? `${parentPath}/folder_${folderIdx}`
+      : `folder_${folderIdx}`
+
+    folder.requests.forEach((_: any, reqIdx: number) => {
+      paths.push(`${folderPath}/request_${reqIdx}`)
+    })
+
+    if (folder.folders && folder.folders.length > 0) {
+      const nestedPaths = buildAllPaths(
+        { requests: [], folders: folder.folders } as any,
+        folderPath
+      )
+      paths.push(...nestedPaths)
+    }
+  })
+
+  return paths
+}
+
+// Initialize all requests as selected immediately at declaration time
+const initStateFromCollection = (): RequestSelectionState => {
+  const paths = buildAllPaths(props.collection)
+  const state: RequestSelectionState = {}
+  paths.forEach((p) => { state[p] = true })
+  return state
+}
+
+const selectionState = ref<RequestSelectionState>(initStateFromCollection())
+
+const emitUpdate = () => {
+  emit("update:modelValue", { ...selectionState.value })
+}
+
+// Emit initial state to parent
+emitUpdate()
+
+const totalCount = computed(() => buildAllPaths(props.collection).length)
+
+const selectedCount = computed(
+  () => Object.values(selectionState.value).filter(Boolean).length
+)
+
+const allSelected = computed(
+  () => totalCount.value > 0 && selectedCount.value === totalCount.value
+)
+
+const selectAll = () => {
+  const allPaths = buildAllPaths(props.collection)
+  const newState: RequestSelectionState = {}
+  allPaths.forEach((path) => { newState[path] = true })
+  selectionState.value = newState
+  emitUpdate()
+}
+
+const deselectAll = () => {
+  const allPaths = buildAllPaths(props.collection)
+  const newState: RequestSelectionState = {}
+  allPaths.forEach((path) => { newState[path] = false })
+  selectionState.value = newState
+  emitUpdate()
+}
+
+const toggleSelectAll = () => {
+  if (allSelected.value) {
+    deselectAll()
+  } else {
+    selectAll()
+  }
+}
+
+const toggleSelection = (path: string) => {
+  selectionState.value = {
+    ...selectionState.value,
+    [path]: !selectionState.value[path],
+  }
+  emitUpdate()
+}
+</script>
diff --git a/packages/hoppscotch-common/src/components/http/test/RequestSelectionTreeNode.vue b/packages/hoppscotch-common/src/components/http/test/RequestSelectionTreeNode.vue
new file mode 100644
index 00000000000..cc4d4fd488d
--- /dev/null
+++ b/packages/hoppscotch-common/src/components/http/test/RequestSelectionTreeNode.vue
@@ -0,0 +1,274 @@
+<template>
+  <div class="flex flex-col">
+    <!-- Folder Node -->
+    <div
+      v-for="(folder, folderIdx) in collection.folders"
+      :key="`folder-${folderIdx}`"
+      class="mb-1"
+    >
+      <div
+        class="flex items-center gap-2 p-2 rounded hover:bg-primaryLight cursor-pointer"
+        @click="toggleFolderExpanded(Number(folderIdx))"
+      >
+        <icon
+          :icon="
+            isFolderExpanded(Number(folderIdx)) ? IconChevronDown : IconChevronRight
+          "
+          class="text-secondaryLight flex-shrink-0"
+        />
+        <HoppSmartCheckbox
+          :on="isFolderSelected(Number(folderIdx))"
+          :indeterminate="isFolderIndeterminate(Number(folderIdx))"
+          @change.stop="toggleFolderSelection(Number(folderIdx))"
+        >
+          <div class="flex items-center gap-2">
+            <icon :icon="IconFolder" class="text-accent flex-shrink-0" />
+            <span class="text-secondaryDark truncate">
+              {{ folder.name }}
+            </span>
+            <span class="text-xs text-secondaryLight">
+              ({{ getFolderRequestCount(folder) }})
+            </span>
+          </div>
+        </HoppSmartCheckbox>
+      </div>
+
+      <!-- Nested content (requests and subfolders) -->
+      <div v-if="isFolderExpanded(Number(folderIdx))" class="ml-6">
+        <!-- Folder requests -->
+        <div
+          v-for="(request, reqIdx) in folder.requests"
+          :key="`folder-${folderIdx}-request-${reqIdx}`"
+          class="flex items-center gap-2 p-2 rounded hover:bg-primaryLight"
+        >
+          <HoppSmartCheckbox
+            :on="isRequestSelected(folderIdx, Number(reqIdx))"
+            @change="toggleRequestSelection(folderIdx, Number(reqIdx))"
+          >
+            <div class="flex items-center gap-2">
+              <span
+                class="text-xs font-medium flex-shrink-0 px-2 py-0.5 rounded"
+                :class="{
+                  'bg-green-500/10 text-green-500': (request as HoppRESTRequest).method === 'GET',
+                  'bg-yellow-500/10 text-yellow-500': (request as HoppRESTRequest).method === 'POST',
+                  'bg-blue-500/10 text-blue-500': (request as HoppRESTRequest).method === 'PUT',
+                  'bg-red-500/10 text-red-500': (request as HoppRESTRequest).method === 'DELETE',
+                  'bg-gray-500/10 text-gray-500': !['GET', 'POST', 'PUT', 'DELETE'].includes((request as HoppRESTRequest).method),
+                }"
+              >
+                {{ (request as HoppRESTRequest).method }}
+              </span>
+              <span class="text-secondaryDark truncate">
+                {{ request.name }}
+              </span>
+            </div>
+          </HoppSmartCheckbox>
+        </div>
+
+        <!-- Recursive nested folders -->
+        <CollectionTreeNode
+          v-if="folder.folders && folder.folders.length > 0"
+          :collection="folder"
+          :selection-state="selectionState"
+          :path="[...path, folderIdx]"
+          @toggle="$emit('toggle', $event)"
+        />
+      </div>
+    </div>
+
+    <!-- Root-level requests -->
+    <div
+      v-for="(request, reqIdx) in collection.requests"
+      :key="`request-${reqIdx}`"
+      class="flex items-center gap-2 p-2 rounded hover:bg-primaryLight"
+    >
+      <HoppSmartCheckbox
+        :on="isRootRequestSelected(Number(reqIdx))"
+        @change="toggleRootRequestSelection(Number(reqIdx))"
+      >
+        <div class="flex items-center gap-2">
+          <span
+            class="text-xs font-medium flex-shrink-0 px-2 py-0.5 rounded"
+            :class="{
+              'bg-green-500/10 text-green-500': (request as HoppRESTRequest).method === 'GET',
+              'bg-yellow-500/10 text-yellow-500': (request as HoppRESTRequest).method === 'POST',
+              'bg-blue-500/10 text-blue-500': (request as HoppRESTRequest).method === 'PUT',
+              'bg-red-500/10 text-red-500': (request as HoppRESTRequest).method === 'DELETE',
+              'bg-gray-500/10 text-gray-500': !['GET', 'POST', 'PUT', 'DELETE'].includes((request as HoppRESTRequest).method),
+            }"
+          >
+            {{ (request as HoppRESTRequest).method }}
+          </span>
+          <span class="text-secondaryDark truncate">
+            {{ request.name }}
+          </span>
+        </div>
+      </HoppSmartCheckbox>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { HoppCollection, HoppRESTRequest } from "@hoppscotch/data"
+import { PropType, ref } from "vue"
+import { RequestSelectionState } from "./RequestSelectionTree.vue"
+import IconChevronDown from "~icons/lucide/chevron-down"
+import IconChevronRight from "~icons/lucide/chevron-right"
+import IconFolder from "~icons/lucide/folder"
+
+const props = defineProps({
+  collection: {
+    type: Object as PropType<HoppCollection>,
+    required: true,
+  },
+  selectionState: {
+    type: Object as PropType<RequestSelectionState>,
+    required: true,
+  },
+  path: {
+    type: Array as PropType<number[]>,
+    default: () => [],
+  },
+})
+
+const emit = defineEmits<{
+  (e: "toggle", path: string): void
+}>()
+
+// Track expanded folders
+const expandedFolders = ref<Set<number>>(new Set())
+
+const toggleFolderExpanded = (folderIdx: number) => {
+  if (expandedFolders.value.has(folderIdx)) {
+    expandedFolders.value.delete(folderIdx)
+  } else {
+    expandedFolders.value.add(folderIdx)
+  }
+}
+
+const isFolderExpanded = (folderIdx: number) => {
+  return expandedFolders.value.has(folderIdx)
+}
+
+// Helper to build path string
+const buildPath = (folderIdx?: number, reqIdx?: number): string => {
+  const basePath = props.path
+    .map((idx) => `folder_${idx}`)
+    .join("/")
+
+  if (folderIdx !== undefined && reqIdx !== undefined) {
+    const folderPath = basePath
+      ? `${basePath}/folder_${folderIdx}`
+      : `folder_${folderIdx}`
+    return `${folderPath}/request_${reqIdx}`
+  } else if (folderIdx !== undefined) {
+    return basePath ? `${basePath}/folder_${folderIdx}` : `folder_${folderIdx}`
+  } else if (reqIdx !== undefined) {
+    return basePath ? `${basePath}/request_${reqIdx}` : `request_${reqIdx}`
+  }
+  return basePath
+}
+
+// Check if a request is selected
+const isRequestSelected = (folderIdx: number, reqIdx: number): boolean => {
+  const path = buildPath(folderIdx, reqIdx)
+  return props.selectionState[path] ?? false
+}
+
+const isRootRequestSelected = (reqIdx: number): boolean => {
+  const path = buildPath(undefined, reqIdx)
+  return props.selectionState[path] ?? false
+}
+
+// Toggle request selection
+const toggleRequestSelection = (folderIdx: number, reqIdx: number) => {
+  const path = buildPath(folderIdx, reqIdx)
+  emit("toggle", path)
+}
+
+const toggleRootRequestSelection = (reqIdx: number) => {
+  const path = buildPath(undefined, reqIdx)
+  emit("toggle", path)
+}
+
+// Count requests in a folder (including nested)
+const getFolderRequestCount = (folder: HoppCollection): number => {
+  let count = folder.requests.length
+
+  if (folder.folders && folder.folders.length > 0) {
+    folder.folders.forEach((subFolder) => {
+      count += getFolderRequestCount(subFolder)
+    })
+  }
+
+  return count
+}
+
+// Check if folder is fully/partially selected
+const getFolderSelectionPaths = (
+  folderIdx: number
+): { allPaths: string[]; selectedPaths: string[] } => {
+  const folder = props.collection.folders[folderIdx]
+  const folderBasePath = buildPath(folderIdx)
+  const allPaths: string[] = []
+
+  // Get all request paths in this folder
+  folder.requests.forEach((_: any, reqIdx: number) => {
+    const path = `${folderBasePath}/request_${reqIdx}`
+    allPaths.push(path)
+  })
+
+  // Recursively get paths from nested folders
+  if (folder.folders && folder.folders.length > 0) {
+    const getNestedPaths = (
+      nestedFolder: HoppCollection,
+      parentPath: string
+    ) => {
+      nestedFolder.requests.forEach((_: any, reqIdx: number) => {
+        const path = `${parentPath}/request_${reqIdx}`
+        allPaths.push(path)
+      })
+
+      nestedFolder.folders?.forEach((subFolder: any, subIdx: number) => {
+        const subFolderPath = `${parentPath}/folder_${subIdx}`
+        getNestedPaths(subFolder, subFolderPath)
+      })
+    }
+
+    folder.folders.forEach((subFolder: any, subIdx: number) => {
+      const subFolderPath = `${folderBasePath}/folder_${subIdx}`
+      getNestedPaths(subFolder, subFolderPath)
+    })
+  }
+
+  const selectedPaths = allPaths.filter((path) => props.selectionState[path])
+
+  return { allPaths, selectedPaths }
+}
+
+const isFolderSelected = (folderIdx: number): boolean => {
+  const { allPaths, selectedPaths } = getFolderSelectionPaths(folderIdx)
+  return allPaths.length > 0 && selectedPaths.length === allPaths.length
+}
+
+const isFolderIndeterminate = (folderIdx: number): boolean => {
+  const { allPaths, selectedPaths } = getFolderSelectionPaths(folderIdx)
+  return (
+    selectedPaths.length > 0 && selectedPaths.length < allPaths.length
+  )
+}
+
+const toggleFolderSelection = (folderIdx: number) => {
+  const { allPaths, selectedPaths } = getFolderSelectionPaths(folderIdx)
+  const shouldSelect = selectedPaths.length !== allPaths.length
+
+  // Toggle all requests in this folder
+  allPaths.forEach((path) => {
+    if (shouldSelect && !props.selectionState[path]) {
+      emit("toggle", path)
+    } else if (!shouldSelect && props.selectionState[path]) {
+      emit("toggle", path)
+    }
+  })
+}
+</script>
diff --git a/packages/hoppscotch-common/src/components/http/test/RunnerModal.vue b/packages/hoppscotch-common/src/components/http/test/RunnerModal.vue
index f285f394b59..1f5813a956e 100644
--- a/packages/hoppscotch-common/src/components/http/test/RunnerModal.vue
+++ b/packages/hoppscotch-common/src/components/http/test/RunnerModal.vue
@@ -3,14 +3,38 @@
     dialog
     :title="t('collection_runner.run_collection')"
     :full-width-body="true"
+    :styles="modalStyles"
     @close="closeModal"
   >
     <template #body>
       <HoppSmartTabs v-model="activeTab">
         <HoppSmartTab id="gui" :label="t('collection_runner.ui')">
-          <div
-            class="flex-shrink-0 w-full h-full p-4 overflow-auto overflow-x-auto bg-primary"
-          >
+          <div class="flex min-h-[600px] h-full">
+            <!-- Left Panel: Request Selection with drag-to-reorder -->
+            <div
+              class="flex flex-col w-3/5 border-r border-divider p-4 overflow-hidden"
+            >
+              <div
+                class="flex-1 overflow-y-auto border rounded border-divider p-2"
+              >
+                <RequestRunOrder
+                  v-if="collectionTreeForSelection"
+                  v-model="requestOrder"
+                  :collection="collectionTreeForSelection"
+                  :selection="requestSelection"
+                  @update:selection="requestSelection = $event"
+                />
+                <div
+                  v-else
+                  class="flex items-center justify-center h-32 text-secondaryLight text-sm"
+                >
+                  {{ t("collection_runner.loading_requests") }}
+                </div>
+              </div>
+            </div>
+
+            <!-- Right Panel: Configuration -->
+            <div class="flex flex-col w-2/5 p-4 overflow-y-auto">
             <section>
               <h4 class="font-semibold text-secondaryDark">
                 {{ t("collection_runner.run_config") }}
@@ -230,7 +254,8 @@
                 </HoppSmartCheckbox>
               </div>
             </section>
-          </div>
+            </div><!-- end right panel -->
+          </div><!-- end flex container -->
         </HoppSmartTab>
 
         <HoppSmartTab id="cli" :label="t('collection_runner.cli')">
@@ -273,6 +298,12 @@
           </template>
         </HoppSmartTab>
         <template #actions>
+          <HoppButtonSecondary
+            v-tippy="{ theme: 'tooltip' }"
+            :title="isExpanded ? t('collection_runner.collapse_modal') : t('collection_runner.expand_modal')"
+            :icon="isExpanded ? IconMinimize2 : IconMaximize2"
+            @click="isExpanded = !isExpanded"
+          />
           <HoppButtonSecondary
             v-tippy="{ theme: 'tooltip' }"
             class="!py-0 pl-2"
@@ -379,9 +410,11 @@ import { useI18n } from "~/composables/i18n"
 import { HoppCollection } from "@hoppscotch/data"
 import { useService } from "dioc/vue"
 import { useToast } from "~/composables/toast"
-import { TestRunnerConfig } from "~/helpers/rest/document"
+import { TestRunnerConfig, RequestSelectionState } from "~/helpers/rest/document"
 import { copyToClipboard } from "~/helpers/utils/clipboard"
 import { RESTTabService } from "~/services/tab/rest"
+import RequestSelectionTree from "./RequestSelectionTree.vue"
+import RequestRunOrder from "./RequestRunOrder.vue"
 import {
   parseCSV,
   parseJSON,
@@ -394,6 +427,8 @@ import IconPlay from "~icons/lucide/play"
 import IconDownload from "~icons/lucide/download"
 import IconEye from "~icons/lucide/eye"
 import IconTrash from "~icons/lucide/trash-2"
+import IconMaximize2 from "~icons/lucide/maximize-2"
+import IconMinimize2 from "~icons/lucide/minimize-2"
 import { CurrentEnv } from "./Env.vue"
 import { pipe } from "fp-ts/lib/function"
 import {
@@ -463,12 +498,72 @@ const config = ref<TestRunnerConfig>({
   keepVariableValues: true,
 })
 
+const requestSelection = ref<RequestSelectionState>({})
+const requestOrder = ref<string[]>([])
+const collectionTreeForSelection = ref<HoppCollection | null>(null)
+const isExpanded = ref(false)
+
+/**
+ * Flatten a collection to a list of request paths in natural traversal order
+ * (folders first, then requests — matching the runner's default order).
+ */
+const buildFlatOrder = (collection: HoppCollection): string[] => {
+  const paths: string[] = []
+  const traverse = (node: HoppCollection, parentPath: string) => {
+    node.folders.forEach((folder, folderIdx) => {
+      const folderSeg = parentPath
+        ? `${parentPath}/folder_${folderIdx}`
+        : `folder_${folderIdx}`
+      traverse(folder as HoppCollection, folderSeg)
+    })
+    node.requests.forEach((_: unknown, reqIdx: number) => {
+      paths.push(
+        parentPath ? `${parentPath}/request_${reqIdx}` : `request_${reqIdx}`
+      )
+    })
+  }
+  traverse(collection, "")
+  return paths
+}
+const modalStyles = computed(() =>
+  isExpanded.value ? "max-w-6xl w-full" : "max-w-4xl w-full"
+)
+
 onMounted(async () => {
   if (props.prevConfig) {
     config.value = { ...config.value, ...props.prevConfig }
   }
+
+  // Load collection tree for request selection
+  const tree = await getCollectionTree(
+    props.collectionRunnerData.type,
+    props.collectionRunnerData.collectionID
+  )
+  
+  if (tree) {
+    collectionTreeForSelection.value = tree
+    // Initialize run order from natural traversal (if not already set from prevConfig)
+    if (requestOrder.value.length === 0) {
+      const flatPaths = buildFlatOrder(tree)
+      requestOrder.value = flatPaths
+      // Default: all requests selected
+      const allSelected: RequestSelectionState = {}
+      flatPaths.forEach((path) => { allSelected[path] = true })
+      requestSelection.value = allSelected
+    }
+  }
 })
 
+// Sync requestSelection with config
+watch(requestSelection, (newSelection) => {
+  config.value.requestSelection = newSelection
+}, { deep: true })
+
+// Sync requestOrder with config
+watch(requestOrder, (newOrder) => {
+  config.value.requestOrder = newOrder
+}, { deep: true })
+
 const runTests = async () => {
   const collectionTree = await getCollectionTree(
     props.collectionRunnerData.type,
diff --git a/packages/hoppscotch-common/src/helpers/rest/document.ts b/packages/hoppscotch-common/src/helpers/rest/document.ts
index bfff60723cd..9c070deb88d 100644
--- a/packages/hoppscotch-common/src/helpers/rest/document.ts
+++ b/packages/hoppscotch-common/src/helpers/rest/document.ts
@@ -95,6 +95,12 @@ export type HoppCollectionSaveContext =
     }
   | null
 
+export type RequestSelectionState = {
+  // Map of request path to selection state
+  // Path format: "folder_0/folder_1/request_2" or "request_0" for root-level requests
+  [path: string]: boolean
+}
+
 export type TestRunnerConfig = {
   iterations: number
   delay: number
@@ -108,6 +114,8 @@ export type TestRunnerConfig = {
     rawContent?: string // Store the original file content for persistence
     fileName?: string // Store the original file name
   }
+  requestSelection?: RequestSelectionState // Track selected/unselected requests
+  requestOrder?: string[] // Custom execution order — flat list of request paths in desired run order
 }
 
 export type HoppTestRunnerDocument = {
diff --git a/packages/hoppscotch-common/src/services/test-runner/test-runner.service.ts b/packages/hoppscotch-common/src/services/test-runner/test-runner.service.ts
index 6b9c0fc84fc..73e8d730568 100644
--- a/packages/hoppscotch-common/src/services/test-runner/test-runner.service.ts
+++ b/packages/hoppscotch-common/src/services/test-runner/test-runner.service.ts
@@ -119,18 +119,30 @@ export class TestRunnerService extends Service {
       }
 
       // Run the collection for this iteration
-      await this.runTestCollection(
-        tab,
-        collection,
-        options,
-        [],
-        undefined,
-        undefined,
-        [],
-        undefined,
-        shouldResetCollection,
-        iterationData
-      )
+      if (options.requestOrder && options.requestOrder.length > 0) {
+        // Custom execution order: use flat order with resolved context
+        await this.runTestsInCustomOrder(
+          tab,
+          collection,
+          options,
+          shouldResetCollection,
+          iterationData
+        )
+      } else {
+        // Default: recursive traversal in natural collection order
+        await this.runTestCollection(
+          tab,
+          collection,
+          options,
+          [],
+          undefined,
+          undefined,
+          [],
+          undefined,
+          shouldResetCollection,
+          iterationData
+        )
+      }
 
       // Add delay between iterations (except after the last one)
       if (iteration < iterations - 1 && options.delay && options.delay > 0) {
@@ -226,6 +238,17 @@ export class TestRunnerService extends Service {
           throw new Error("Test execution stopped")
         }
 
+        // Check if this request should be executed based on selection state
+        const requestPath = this.buildRequestPath(parentPath, i)
+        const shouldExecute = this.shouldExecuteRequest(
+          requestPath,
+          options.requestSelection
+        )
+
+        if (!shouldExecute) {
+          continue // Skip this request if not selected
+        }
+
         const request = collection.requests[i] as TestRunnerRequest
         const currentPath = [...parentPath, i]
 
@@ -507,4 +530,213 @@ export class TestRunnerService extends Service {
 
     return { passed, failed }
   }
+
+  /**
+   * Resolves a string path (e.g. "folder_0/folder_1/request_2") to the actual
+   * request plus its inherited auth, headers, and parent path array.
+   */
+  private resolveRequestContext(
+    collection: HoppCollection,
+    pathStr: string
+  ): {
+    request: TestRunnerRequest
+    parentPath: number[]
+    requestIndex: number
+    inheritedAuth: HoppRESTRequest["auth"]
+    inheritedHeaders: HoppRESTHeaders
+  } | null {
+    const parts = pathStr.split("/")
+    let current: HoppCollection = collection
+    const parentPath: number[] = []
+
+    // Start with root-level auth/headers
+    let inheritedAuth: HoppRESTRequest["auth"] =
+      collection.auth?.authType === "inherit"
+        ? { authType: "none", authActive: false }
+        : collection.auth || { authType: "none", authActive: false }
+
+    let inheritedHeaders: HoppRESTHeaders = [...(collection.headers || [])]
+
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i]
+      const isLast = i === parts.length - 1
+
+      if (part.startsWith("folder_")) {
+        const folderIdx = parseInt(part.replace("folder_", ""), 10)
+        if (isLast) return null // path ends in folder, not a request
+
+        const folder = current.folders[folderIdx]
+        if (!folder) return null
+
+        // Accumulate auth/headers from this folder
+        inheritedAuth =
+          folder.auth?.authType === "inherit" && folder.auth?.authActive
+            ? inheritedAuth
+            : folder.auth || { authType: "none", authActive: false }
+
+        inheritedHeaders = [...inheritedHeaders, ...(folder.headers || [])]
+
+        parentPath.push(folderIdx)
+        current = folder as HoppCollection
+      } else if (part.startsWith("request_")) {
+        const reqIdx = parseInt(part.replace("request_", ""), 10)
+        const request = current.requests[reqIdx]
+        if (!request) return null
+
+        return {
+          request: request as TestRunnerRequest,
+          parentPath,
+          requestIndex: reqIdx,
+          inheritedAuth,
+          inheritedHeaders,
+        }
+      } else {
+        return null // unknown segment
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Pre-populates all folder nodes in the result collection from the source
+   * collection. This is required before custom-order execution so that
+   * appendRequestToPath / updateRequestAtPath can navigate into sub-folders.
+   */
+  private buildFolderSkeleton(
+    resultCollection: HoppCollection,
+    sourceCollection: HoppCollection,
+    path: number[] = []
+  ): void {
+    sourceCollection.folders.forEach((folder, i) => {
+      const folderPath = [...path, i]
+      this.addFolderToPath(resultCollection, folderPath, {
+        ...cloneDeep(folder),
+        folders: [],
+        requests: [],
+      })
+      this.buildFolderSkeleton(
+        resultCollection,
+        folder as HoppCollection,
+        folderPath
+      )
+    })
+  }
+
+  /**
+   * Executes requests in the user-defined flat order stored in options.requestOrder.
+   * Auth/header inheritance is resolved for each request individually.
+   */
+  private async runTestsInCustomOrder(
+    tab: Ref<HoppTab<HoppTestRunnerDocument>>,
+    collection: HoppCollection,
+    options: TestRunnerOptions,
+    shouldResetFoldersAndRequests: boolean,
+    iterationData?: any
+  ) {
+    // On the first iteration, pre-populate the folder tree in the result collection
+    // so that appendRequestToPath can navigate into sub-folders safely.
+    if (shouldResetFoldersAndRequests) {
+      this.buildFolderSkeleton(tab.value.document.resultCollection!, collection)
+    }
+
+    // Sequential per-folder insertion counter so that the result collection always
+    // stores requests in the dragged custom order — not by their original array index.
+    // Without this, shouldReplaceAtIndex=true (first iteration) would write each
+    // request at its ORIGINAL index, recreating the default order on run 1.
+    const folderRequestCounters = new Map<string, number>()
+
+    for (const requestPath of options.requestOrder!) {
+      if (options.stopRef?.value) {
+        tab.value.document.status = "stopped"
+        throw new Error("Test execution stopped")
+      }
+
+      // Honour selection: skip deselected requests
+      const shouldExecute = this.shouldExecuteRequest(
+        requestPath,
+        options.requestSelection
+      )
+      if (!shouldExecute) continue
+
+      // Resolve the request and its inherited context from the collection tree
+      const ctx = this.resolveRequestContext(collection, requestPath)
+      if (!ctx) continue
+
+      const { request, parentPath, inheritedAuth, inheritedHeaders } = ctx
+
+      // Use a sequential per-folder counter as the insertion index.
+      // This keeps the result collection in custom order regardless of the
+      // request's original position in the source collection.
+      const folderKey = parentPath.join("/")
+      const seqIndex = folderRequestCounters.get(folderKey) ?? 0
+      folderRequestCounters.set(folderKey, seqIndex + 1)
+
+      const fullPath = [...parentPath, seqIndex]
+
+      // Add request slot to the result collection
+      this.appendRequestToPath(
+        tab.value.document.resultCollection!,
+        fullPath,
+        cloneDeep(request),
+        shouldResetFoldersAndRequests
+      )
+
+      // Apply inherited auth and headers
+      const finalRequest: TestRunnerRequest = {
+        ...request,
+        auth:
+          request.auth.authType === "inherit" && request.auth.authActive
+            ? inheritedAuth
+            : request.auth,
+        headers: [...inheritedHeaders, ...request.headers],
+      }
+
+      await this.runTestRequest(
+        tab,
+        finalRequest,
+        collection,
+        options,
+        fullPath,
+        [], // inherited variables — simplified for custom order
+        shouldResetFoldersAndRequests,
+        iterationData
+      )
+
+      if (options.delay && options.delay > 0) {
+        try {
+          await delay(options.delay)
+        } catch (_error) {
+          if (options.stopRef?.value) {
+            tab.value.document.status = "stopped"
+            throw new Error("Test execution stopped")
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Builds a request path string from a path array
+   * Example: [0, 1, 2] -> "folder_0/folder_1/request_2"
+   */
+  private buildRequestPath(parentPath: number[], requestIndex: number): string {
+    const folderPath = parentPath.map((idx) => `folder_${idx}`).join("/")
+    const requestPath = `request_${requestIndex}`
+    return folderPath ? `${folderPath}/${requestPath}` : requestPath
+  }
+
+  /**
+   * Checks if a request should be executed based on selection state
+   * If no selection state is provided, all requests are executed
+   */
+  private shouldExecuteRequest(
+    requestPath: string,
+    selectionState?: Record<string, boolean>
+  ): boolean {
+    if (!selectionState || Object.keys(selectionState).length === 0) {
+      return true // Execute all if no selection state
+    }
+    return selectionState[requestPath] ?? false
+  }
 }