diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 8ceecb3abb4a2..1aefeee710f47 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -24,4 +24,4 @@
 
 /.github/ @peternied
 
-/MAINTAINERS.md @anasalkouz @andrross @ashking94 @Bukhtawar @CEHENKLE @dblock @dbwiddis @gbbafna @jed326 @kotwanikunal @mch2 @msfroh @nknize @owaiskazi19 @peternied @reta @Rishikesh1159 @sachinpkale @saratvemulapalli @shwetathareja @sohami @VachaShah
+/MAINTAINERS.md @anasalkouz @andrross @ashking94 @Bukhtawar @CEHENKLE @dblock @dbwiddis @gaobinlong @gbbafna @jed326 @kotwanikunal @mch2 @msfroh @nknize @owaiskazi19 @peternied @reta @Rishikesh1159 @sachinpkale @saratvemulapalli @shwetathareja @sohami @VachaShah
diff --git a/.github/benchmark-configs.json b/.github/benchmark-configs.json
new file mode 100644
index 0000000000000..5b44198cd3b8e
--- /dev/null
+++ b/.github/benchmark-configs.json
@@ -0,0 +1,161 @@
+{
+  "name": "Cluster and opensearch-benchmark configurations",
+  "id_1": {
+    "description": "Indexing only configuration for NYC_TAXIS workload",
+    "supported_major_versions": ["2", "3"],
+    "cluster-benchmark-configs": {
+      "SINGLE_NODE_CLUSTER": "true",
+      "MIN_DISTRIBUTION": "true",
+      "TEST_WORKLOAD": "nyc_taxis",
+      "WORKLOAD_PARAMS": "{\"number_of_replicas\":\"0\",\"number_of_shards\":\"1\"}",
+      "EXCLUDE_TASKS": "type:search",
+      "CAPTURE_NODE_STAT": "true"
+    },
+    "cluster_configuration": {
+      "size": "Single-Node",
+      "data_instance_config": "4vCPU, 32G Mem, 16G Heap"
+    }
+  },
+  "id_2": {
+    "description": "Indexing only configuration for HTTP_LOGS workload",
+    "supported_major_versions": ["2", "3"],
+    "cluster-benchmark-configs": {
+      "SINGLE_NODE_CLUSTER": "true",
+      "MIN_DISTRIBUTION": "true",
+      "TEST_WORKLOAD": "http_logs",
+      "WORKLOAD_PARAMS": "{\"number_of_replicas\":\"0\",\"number_of_shards\":\"1\"}",
+      "EXCLUDE_TASKS": "type:search",
+      "CAPTURE_NODE_STAT": "true"
+    },
+    "cluster_configuration": {
+      "size": "Single-Node",
+      "data_instance_config": "4vCPU, 32G Mem, 16G Heap"
+    }
+  },
+  "id_3": {
+    "description": "Search only test-procedure for NYC_TAXIS, uses snapshot to restore the data for OS-3.0.0",
+    "supported_major_versions": ["3"],
+    "cluster-benchmark-configs": {
+      "SINGLE_NODE_CLUSTER": "true",
+      "MIN_DISTRIBUTION": "true",
+      "TEST_WORKLOAD": "nyc_taxis",
+      "WORKLOAD_PARAMS": "{\"snapshot_repo_name\":\"benchmark-workloads-repo-300\",\"snapshot_bucket_name\":\"benchmark-workload-snapshots\",\"snapshot_region\":\"us-east-1\",\"snapshot_base_path\":\"workload-snapshots-300\",\"snapshot_name\":\"nyc_taxis_1_shard\"}",
+      "CAPTURE_NODE_STAT": "true",
+      "TEST_PROCEDURE": "restore-from-snapshot"
+    },
+    "cluster_configuration": {
+      "size": "Single-Node",
+      "data_instance_config": "4vCPU, 32G Mem, 16G Heap"
+    }
+  },
+  "id_4": {
+    "description": "Search only test-procedure for HTTP_LOGS, uses snapshot to restore the data for OS-3.0.0",
+    "supported_major_versions": ["3"],
+    "cluster-benchmark-configs": {
+      "SINGLE_NODE_CLUSTER": "true",
+      "MIN_DISTRIBUTION": "true",
+      "TEST_WORKLOAD": "http_logs",
+      "WORKLOAD_PARAMS": "{\"snapshot_repo_name\":\"benchmark-workloads-repo-300\",\"snapshot_bucket_name\":\"benchmark-workload-snapshots\",\"snapshot_region\":\"us-east-1\",\"snapshot_base_path\":\"workload-snapshots-300\",\"snapshot_name\":\"http_logs_1_shard\"}",
+      "CAPTURE_NODE_STAT": "true",
+      "TEST_PROCEDURE": "restore-from-snapshot"
+    },
+    "cluster_configuration": {
+      "size": "Single-Node",
+      "data_instance_config": "4vCPU, 32G Mem, 16G Heap"
+    }
+  },
+  "id_5": {
+    "description": "Search only test-procedure for HTTP_LOGS, uses snapshot to restore the data for OS-3.0.0",
+    "supported_major_versions": ["3"],
+    "cluster-benchmark-configs": {
+      "SINGLE_NODE_CLUSTER": "true",
+      "MIN_DISTRIBUTION": "true",
+      "TEST_WORKLOAD": "big5",
+      "WORKLOAD_PARAMS": "{\"snapshot_repo_name\":\"benchmark-workloads-repo-300\",\"snapshot_bucket_name\":\"benchmark-workload-snapshots\",\"snapshot_region\":\"us-east-1\",\"snapshot_base_path\":\"workload-snapshots-300\",\"snapshot_name\":\"big5_1_shard\"}",
+      "CAPTURE_NODE_STAT": "true",
+      "TEST_PROCEDURE": "restore-from-snapshot"
+    },
+    "cluster_configuration": {
+      "size": "Single-Node",
+      "data_instance_config": "4vCPU, 32G Mem, 16G Heap"
+    }
+  },
+  "id_6": {
+    "description": "Search only test-procedure for NYC_TAXIS, uses snapshot to restore the data for OS-2.x",
+    "supported_major_versions": ["2"],
+    "cluster-benchmark-configs": {
+      "SINGLE_NODE_CLUSTER": "true",
+      "MIN_DISTRIBUTION": "true",
+      "TEST_WORKLOAD": "nyc_taxis",
+      "WORKLOAD_PARAMS": "{\"snapshot_repo_name\":\"benchmark-workloads-repo\",\"snapshot_bucket_name\":\"benchmark-workload-snapshots\",\"snapshot_region\":\"us-east-1\",\"snapshot_base_path\":\"workload-snapshots\",\"snapshot_name\":\"nyc_taxis_1_shard\"}",
+      "CAPTURE_NODE_STAT": "true",
+      "TEST_PROCEDURE": "restore-from-snapshot"
+    },
+    "cluster_configuration": {
+      "size": "Single-Node",
+      "data_instance_config": "4vCPU, 32G Mem, 16G Heap"
+    }
+  },
+  "id_7": {
+    "description": "Search only test-procedure for HTTP_LOGS, uses snapshot to restore the data for OS-2.x",
+    "supported_major_versions": ["2"],
+    "cluster-benchmark-configs": {
+      "SINGLE_NODE_CLUSTER": "true",
+      "MIN_DISTRIBUTION": "true",
+      "TEST_WORKLOAD": "http_logs",
+      "WORKLOAD_PARAMS": "{\"snapshot_repo_name\":\"benchmark-workloads-repo\",\"snapshot_bucket_name\":\"benchmark-workload-snapshots\",\"snapshot_region\":\"us-east-1\",\"snapshot_base_path\":\"workload-snapshots\",\"snapshot_name\":\"http_logs_1_shard\"}",
+      "CAPTURE_NODE_STAT": "true",
+      "TEST_PROCEDURE": "restore-from-snapshot"
+    },
+    "cluster_configuration": {
+      "size": "Single-Node",
+      "data_instance_config": "4vCPU, 32G Mem, 16G Heap"
+    }
+  },
+  "id_8": {
+    "description": "Search only test-procedure for HTTP_LOGS, uses snapshot to restore the data for OS-2.x",
+    "supported_major_versions": ["2"],
+    "cluster-benchmark-configs": {
+      "SINGLE_NODE_CLUSTER": "true",
+      "MIN_DISTRIBUTION": "true",
+      "TEST_WORKLOAD": "big5",
+      "WORKLOAD_PARAMS": "{\"snapshot_repo_name\":\"benchmark-workloads-repo\",\"snapshot_bucket_name\":\"benchmark-workload-snapshots\",\"snapshot_region\":\"us-east-1\",\"snapshot_base_path\":\"workload-snapshots\",\"snapshot_name\":\"big5_1_shard\"}",
+      "CAPTURE_NODE_STAT": "true",
+      "TEST_PROCEDURE": "restore-from-snapshot"
+    },
+    "cluster_configuration": {
+      "size": "Single-Node",
+      "data_instance_config": "4vCPU, 32G Mem, 16G Heap"
+    }
+  },
+  "id_9": {
+    "description": "Indexing and search configuration for pmc workload",
+    "supported_major_versions": ["2", "3"],
+    "cluster-benchmark-configs": {
+      "SINGLE_NODE_CLUSTER": "true",
+      "MIN_DISTRIBUTION": "true",
+      "TEST_WORKLOAD": "pmc",
+      "WORKLOAD_PARAMS": "{\"number_of_replicas\":\"0\",\"number_of_shards\":\"1\"}",
+      "CAPTURE_NODE_STAT": "true"
+    },
+    "cluster_configuration": {
+      "size": "Single-Node",
+      "data_instance_config": "4vCPU, 32G Mem, 16G Heap"
+    }
+  },
+  "id_10": {
+    "description": "Indexing only configuration for stack-overflow workload",
+    "supported_major_versions": ["2", "3"],
+    "cluster-benchmark-configs": {
+      "SINGLE_NODE_CLUSTER": "true",
+      "MIN_DISTRIBUTION": "true",
+      "TEST_WORKLOAD": "so",
+      "WORKLOAD_PARAMS": "{\"number_of_replicas\":\"0\",\"number_of_shards\":\"1\"}",
+      "CAPTURE_NODE_STAT": "true"
+    },
+    "cluster_configuration": {
+      "size": "Single-Node",
+      "data_instance_config": "4vCPU, 32G Mem, 16G Heap"
+    }
+  }
+}
diff --git a/.github/workflows/add-performance-comment.yml b/.github/workflows/add-performance-comment.yml
new file mode 100644
index 0000000000000..b522d348c84b2
--- /dev/null
+++ b/.github/workflows/add-performance-comment.yml
@@ -0,0 +1,25 @@
+name: Performance Label Action
+
+on:
+  pull_request_target:
+    types: [labeled]
+
+jobs:
+  add-comment:
+    if: github.event.label.name == 'Performance'
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+
+    steps:
+      - name: Add comment to PR
+        uses: actions/github-script@v6
+        with:
+          github-token: ${{secrets.GITHUB_TOKEN}}
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: "Hello!\nWe have added a performance benchmark workflow that runs by adding a comment on the PR.\n Please refer https://github.com/opensearch-project/OpenSearch/blob/main/PERFORMANCE_BENCHMARKS.md on how to run benchmarks on pull requests."
+            })
diff --git a/.github/workflows/benchmark-pull-request.yml b/.github/workflows/benchmark-pull-request.yml
new file mode 100644
index 0000000000000..9d83331e81d5a
--- /dev/null
+++ b/.github/workflows/benchmark-pull-request.yml
@@ -0,0 +1,163 @@
+name: Run performance benchmark on pull request
+on:
+  issue_comment:
+    types: [created]
+jobs:
+  run-performance-benchmark-on-pull-request:
+    if: ${{ (github.event.issue.pull_request) && (contains(github.event.comment.body, '"run-benchmark-test"')) }}
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+      issues: write
+      pull-requests: write
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+      - name: Set up required env vars
+        run: |
+          echo "PR_NUMBER=${{ github.event.issue.number }}" >> $GITHUB_ENV
+          echo "REPOSITORY=${{ github.event.repository.full_name }}" >> $GITHUB_ENV
+          OPENSEARCH_VERSION=$(awk -F '=' '/^opensearch[[:space:]]*=/ {gsub(/[[:space:]]/, "", $2); print $2}' buildSrc/version.properties)
+          echo "OPENSEARCH_VERSION=$OPENSEARCH_VERSION" >> $GITHUB_ENV
+          major_version=$(echo $OPENSEARCH_VERSION | cut -d'.' -f1)
+          echo "OPENSEARCH_MAJOR_VERSION=$major_version" >> $GITHUB_ENV
+          echo "USER_TAGS=pull_request_number:${{ github.event.issue.number }},repository:OpenSearch" >> $GITHUB_ENV
+      - name: Check comment format
+        id: check_comment
+        uses: actions/github-script@v6
+        with:
+          script: |
+            const fs = require('fs');
+            const comment = context.payload.comment.body;
+            let commentJson;
+            try {
+              commentJson = JSON.parse(comment);
+            } catch (error) {
+              core.setOutput('invalid', 'true');
+              return;
+            }
+            if (!commentJson.hasOwnProperty('run-benchmark-test')) {
+              core.setOutput('invalid', 'true');
+              return;
+            }
+            const configId = commentJson['run-benchmark-test'];
+            let benchmarkConfigs;
+            try {
+              benchmarkConfigs = JSON.parse(fs.readFileSync('.github/benchmark-configs.json', 'utf8'));
+            } catch (error) {
+              core.setFailed('Failed to read benchmark-configs.json');
+              return;
+            }
+            const openSearchMajorVersion = process.env.OPENSEARCH_MAJOR_VERSION;
+            console.log('MAJOR_VERSION', openSearchMajorVersion)
+            if (!benchmarkConfigs.hasOwnProperty(configId) ||
+              !benchmarkConfigs[configId].supported_major_versions.includes(openSearchMajorVersion)) {
+              core.setOutput('invalid', 'true');
+              return;
+            }
+            const clusterBenchmarkConfigs = benchmarkConfigs[configId]['cluster-benchmark-configs'];
+            for (const [key, value] of Object.entries(clusterBenchmarkConfigs)) {
+              core.exportVariable(key, value);
+            }
+      - name: Post invalid format comment
+        if: steps.check_comment.outputs.invalid == 'true'
+        uses: actions/github-script@v6
+        with:
+          github-token: ${{secrets.GITHUB_TOKEN}}
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: 'Invalid comment format or config id. Please refer to https://github.com/opensearch-project/OpenSearch/blob/main/PERFORMANCE_BENCHMARKS.md on how to run benchmarks on pull requests.'
+            })
+      - name: Fail workflow for invalid comment
+        if: steps.check_comment.outputs.invalid == 'true'
+        run: |
+          echo "Invalid comment format detected. Failing the workflow."
+          exit 1
+      - id: get_approvers
+        run: |
+          echo "approvers=$(cat .github/CODEOWNERS | grep '^\*'  | tr -d '* ' | sed 's/@/,/g' | sed 's/,//1')" >> $GITHUB_OUTPUT
+      - uses: trstringer/manual-approval@v1
+        if: (!contains(steps.get_approvers.outputs.approvers, github.event.comment.user.login))
+        with:
+          secret: ${{ github.TOKEN }}
+          approvers: ${{ steps.get_approvers.outputs.approvers }}
+          minimum-approvals: 1
+          issue-title: 'Request to approve/deny benchmark run for PR #${{ env.PR_NUMBER }}'
+          issue-body: "Please approve or deny the benchmark run for PR #${{ env.PR_NUMBER }}"
+          exclude-workflow-initiator-as-approver: false
+      - name: Get PR Details
+        id: get_pr
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const issue = context.payload.issue;
+            const prNumber = issue.number;
+            console.log(`Pull Request Number: ${prNumber}`);
+
+            const { data: pull_request } = await github.rest.pulls.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              pull_number: prNumber,
+            });
+
+            return {
+              "headRepoFullName": pull_request.head.repo.full_name,
+              "headRef": pull_request.head.ref
+            };
+      - name: Set pr details env vars
+        run: |
+          echo '${{ steps.get_pr.outputs.result }}' | jq -r '.headRepoFullName'
+          echo '${{ steps.get_pr.outputs.result }}' | jq -r '.headRef'
+          headRepo=$(echo '${{ steps.get_pr.outputs.result }}' | jq -r '.headRepoFullName')
+          headRef=$(echo '${{ steps.get_pr.outputs.result }}' | jq -r '.headRef')
+          echo "prHeadRepo=$headRepo" >> $GITHUB_ENV
+          echo "prHeadRef=$headRef" >> $GITHUB_ENV
+      - name: Checkout PR Repo
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ env.prHeadRepo }}
+          ref: ${{ env.prHeadRef }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Setup Java
+        uses: actions/setup-java@v1
+        with:
+          java-version: 21
+      - name: Build and Assemble OpenSearch from PR
+        run: |
+          ./gradlew :distribution:archives:linux-tar:assemble -Dbuild.snapshot=false
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          role-to-assume: ${{ secrets.UPLOAD_ARCHIVE_ARTIFACT_ROLE }}
+          role-session-name: publish-to-s3
+          aws-region: us-west-2
+      - name: Push to S3
+        run: |
+          aws s3 cp distribution/archives/linux-tar/build/distributions/opensearch-min-$OPENSEARCH_VERSION-linux-x64.tar.gz s3://${{ secrets.ARCHIVE_ARTIFACT_BUCKET_NAME }}/PR-$PR_NUMBER/
+          echo "DISTRIBUTION_URL=${{ secrets.ARTIFACT_BUCKET_CLOUDFRONT_URL }}/PR-$PR_NUMBER/opensearch-min-$OPENSEARCH_VERSION-linux-x64.tar.gz" >> $GITHUB_ENV
+      - name: Checkout opensearch-build repo
+        uses: actions/checkout@v4
+        with:
+          repository: opensearch-project/opensearch-build
+          ref: main
+          path: opensearch-build
+      - name: Trigger jenkins workflow to run gradle check
+        run: |
+          cat $GITHUB_ENV
+          bash opensearch-build/scripts/benchmark/benchmark-pull-request.sh ${{ secrets.JENKINS_PR_BENCHMARK_GENERIC_WEBHOOK_TOKEN }}
+      - name: Update PR with Job Url
+        uses: actions/github-script@v6
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const workflowUrl = process.env.WORKFLOW_URL;
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: `The Jenkins job url is ${workflowUrl} . Final results will be published once the job is completed.`
+            })
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7050e7d23b24d..6aa3d7a58dda4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -18,6 +18,19 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - Create SystemIndexRegistry with helper method matchesSystemIndex ([#14415](https://github.com/opensearch-project/OpenSearch/pull/14415))
 - Print reason why parent task was cancelled ([#14604](https://github.com/opensearch-project/OpenSearch/issues/14604))
 - Add matchesPluginSystemIndexPattern to SystemIndexRegistry ([#14750](https://github.com/opensearch-project/OpenSearch/pull/14750))
+- Add Plugin interface for loading application based configuration templates (([#14659](https://github.com/opensearch-project/OpenSearch/issues/14659)))
+- Refactor remote-routing-table service inline with remote state interfaces([#14668](https://github.com/opensearch-project/OpenSearch/pull/14668))
+- Add shard-diff path to diff manifest to reduce number of read calls remote store (([#14684](https://github.com/opensearch-project/OpenSearch/pull/14684)))
+- Add SortResponseProcessor to Search Pipelines (([#14785](https://github.com/opensearch-project/OpenSearch/issues/14785)))
+- Add prefix mode verification setting for repository verification (([#14790](https://github.com/opensearch-project/OpenSearch/pull/14790)))
+- Add SplitResponseProcessor to Search Pipelines (([#14800](https://github.com/opensearch-project/OpenSearch/issues/14800)))
+- Optimize TransportNodesAction to not send DiscoveryNodes for NodeStats, NodesInfo and ClusterStats call ([14749](https://github.com/opensearch-project/OpenSearch/pull/14749))
+- Reduce logging in DEBUG for MasterService:run ([#14795](https://github.com/opensearch-project/OpenSearch/pull/14795))
+- Enabling term version check on local state for all ClusterManager Read Transport Actions ([#14273](https://github.com/opensearch-project/OpenSearch/pull/14273))
+- Add persian_stem filter (([#14847](https://github.com/opensearch-project/OpenSearch/pull/14847)))
+- Create listener to refresh search thread resource usage ([#14832](https://github.com/opensearch-project/OpenSearch/pull/14832))
+- Add rest, transport layer changes for hot to warm tiering - dedicated setup (([#13980](https://github.com/opensearch-project/OpenSearch/pull/13980))
+- Optimize Cluster Stats Indices to precomute node level stats ([#14426](https://github.com/opensearch-project/OpenSearch/pull/14426))
 
 ### Dependencies
 - Bump `org.gradle.test-retry` from 1.5.8 to 1.5.9 ([#13442](https://github.com/opensearch-project/OpenSearch/pull/13442))
@@ -29,16 +42,17 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - Bump `commons-net:commons-net` from 3.10.0 to 3.11.1 ([#14396](https://github.com/opensearch-project/OpenSearch/pull/14396))
 - Bump `com.nimbusds:nimbus-jose-jwt` from 9.37.3 to 9.40 ([#14398](https://github.com/opensearch-project/OpenSearch/pull/14398))
 - Bump `org.apache.commons:commons-configuration2` from 2.10.1 to 2.11.0 ([#14399](https://github.com/opensearch-project/OpenSearch/pull/14399))
-- Bump `com.gradle.develocity` from 3.17.4 to 3.17.5 ([#14397](https://github.com/opensearch-project/OpenSearch/pull/14397))
+- Bump `com.gradle.develocity` from 3.17.4 to 3.17.6 ([#14397](https://github.com/opensearch-project/OpenSearch/pull/14397), [#14856](https://github.com/opensearch-project/OpenSearch/pull/14856))
 - Bump `opentelemetry` from 1.36.0 to 1.40.0 ([#14457](https://github.com/opensearch-project/OpenSearch/pull/14457), [#14674](https://github.com/opensearch-project/OpenSearch/pull/14674))
 - Bump `opentelemetry-semconv` from 1.25.0-alpha to 1.26.0-alpha ([#14674](https://github.com/opensearch-project/OpenSearch/pull/14674))
 - Bump `azure-identity` from 1.11.4 to 1.13.0, Bump `msal4j` from 1.14.3 to 1.15.1, Bump `msal4j-persistence-extension` from 1.2.0 to 1.3.0 ([#14506](https://github.com/opensearch-project/OpenSearch/pull/14673))
 - Bump `com.azure:azure-storage-common` from 12.21.2 to 12.25.1 ([#14517](https://github.com/opensearch-project/OpenSearch/pull/14517))
-- Bump `com.microsoft.azure:msal4j` from 1.15.1 to 1.16.0 ([#14610](https://github.com/opensearch-project/OpenSearch/pull/14610))
+- Bump `com.microsoft.azure:msal4j` from 1.15.1 to 1.16.1 ([#14610](https://github.com/opensearch-project/OpenSearch/pull/14610), [#14857](https://github.com/opensearch-project/OpenSearch/pull/14857))
 - Bump `com.github.spullara.mustache.java:compiler` from 0.9.13 to 0.9.14 ([#14672](https://github.com/opensearch-project/OpenSearch/pull/14672))
 - Bump `net.minidev:accessors-smart` from 2.5.0 to 2.5.1 ([#14673](https://github.com/opensearch-project/OpenSearch/pull/14673))
 - Bump `jackson` from 2.17.1 to 2.17.2 ([#14687](https://github.com/opensearch-project/OpenSearch/pull/14687))
 - Bump `net.minidev:json-smart` from 2.5.0 to 2.5.1 ([#14748](https://github.com/opensearch-project/OpenSearch/pull/14748))
+- Bump `actions/checkout` from 2 to 4 ([#14858](https://github.com/opensearch-project/OpenSearch/pull/14858))
 
 ### Changed
 - [Tiered Caching] Move query recomputation logic outside write lock ([#14187](https://github.com/opensearch-project/OpenSearch/pull/14187))
@@ -50,11 +64,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - Allow system index warning in OpenSearchRestTestCase.refreshAllIndices ([#14635](https://github.com/opensearch-project/OpenSearch/pull/14635))
 
 ### Deprecated
+- Deprecate batch_size parameter on bulk API ([#14725](https://github.com/opensearch-project/OpenSearch/pull/14725))
 
 ### Removed
 - Remove query categorization changes ([#14759](https://github.com/opensearch-project/OpenSearch/pull/14759))
 
 ### Fixed
+- Fix allowUnmappedFields, mapUnmappedFieldAsString settings are not applied when parsing certain types of query string query ([#13957](https://github.com/opensearch-project/OpenSearch/pull/13957))
 - Fix bug in SBP cancellation logic ([#13259](https://github.com/opensearch-project/OpenSearch/pull/13474))
 - Fix handling of Short and Byte data types in ScriptProcessor ingest pipeline ([#14379](https://github.com/opensearch-project/OpenSearch/issues/14379))
 - Switch to iterative version of WKT format parser ([#14086](https://github.com/opensearch-project/OpenSearch/pull/14086))
@@ -71,7 +87,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - Fix create or update alias API doesn't throw exception for unsupported parameters ([#14719](https://github.com/opensearch-project/OpenSearch/pull/14719))
 - Refactoring FilterPath.parse by using an iterative approach ([#14200](https://github.com/opensearch-project/OpenSearch/pull/14200))
 - Refactoring Grok.validatePatternBank by using an iterative approach ([#14206](https://github.com/opensearch-project/OpenSearch/pull/14206))
+- Fix NPE when creating index with index.number_of_replicas set to null ([#14812](https://github.com/opensearch-project/OpenSearch/pull/14812))
 - Update help output for _cat ([#14722](https://github.com/opensearch-project/OpenSearch/pull/14722))
+- Fix bulk upsert ignores the default_pipeline and final_pipeline when auto-created index matches the index template ([#12891](https://github.com/opensearch-project/OpenSearch/pull/12891))
+- Fix NPE in ReplicaShardAllocator ([#14385](https://github.com/opensearch-project/OpenSearch/pull/14385))
+- Fix constant_keyword field type used when creating index ([#14807](https://github.com/opensearch-project/OpenSearch/pull/14807))
+- Use circuit breaker in InternalHistogram when adding empty buckets ([#14754](https://github.com/opensearch-project/OpenSearch/pull/14754))
+- Fix searchable snapshot failure with scripted fields ([#14411](https://github.com/opensearch-project/OpenSearch/pull/14411))
 
 ### Security
 
diff --git a/MAINTAINERS.md b/MAINTAINERS.md
index 3298ceb15463c..f77c69ddeff2a 100644
--- a/MAINTAINERS.md
+++ b/MAINTAINERS.md
@@ -14,6 +14,7 @@ This document contains a list of maintainers in this repo. See [opensearch-proje
 | Charlotte Henkle         | [CEHENKLE](https://github.com/CEHENKLE)                 | Amazon      |
 | Dan Widdis               | [dbwiddis](https://github.com/dbwiddis)                 | Amazon      |
 | Daniel "dB." Doubrovkine | [dblock](https://github.com/dblock)                     | Amazon      |
+| Gao Binlong              | [gaobinlong](https://github.com/gaobinlong)             | Amazon      |
 | Gaurav Bafna             | [gbbafna](https://github.com/gbbafna)                   | Amazon      |
 | Jay Deng                 | [jed326](https://github.com/jed326)                     | Amazon      |
 | Kunal Kotwani            | [kotwanikunal](https://github.com/kotwanikunal)         | Amazon      |
diff --git a/PERFORMANCE_BENCHMARKS.md b/PERFORMANCE_BENCHMARKS.md
new file mode 100644
index 0000000000000..252c4ae312136
--- /dev/null
+++ b/PERFORMANCE_BENCHMARKS.md
@@ -0,0 +1,112 @@
+# README: Running Performance Benchmarks on Pull Requests
+
+## Overview
+
+`benchmark-pull-request` GitHub Actions workflow is designed to automatically run performance benchmarks on a pull request when a specific comment is made on the pull request. This ensures that performance benchmarks are consistently and accurately applied to code changes, helping maintain the performance standards of the repository.
+
+## Workflow Trigger
+
+The workflow is triggered when a new comment is created on a pull request. Specifically, it checks for the presence of the `"run-benchmark-test"` keyword in the comment body. If this keyword is detected, the workflow proceeds to run the performance benchmarks.
+
+## Key Steps in the Workflow
+
+1. **Check Comment Format and Configuration:**
+    - Validates the format of the comment to ensure it contains the required `"run-benchmark-test"` keyword and is in json format.
+    - Extracts the benchmark configuration ID from the comment and verifies if it exists in the `benchmark-config.json` file.
+    - Checks if the extracted configuration ID is supported for the current OpenSearch major version.
+
+2. **Post Invalid Format Comment:**
+    - If the comment format is invalid or the configuration ID is not supported, a comment is posted on the pull request indicating the problem, and the workflow fails.
+
+3. **Manual Approval (if necessary):**
+    - Fetches the list of approvers from the `.github/CODEOWNERS` file.
+    - If the commenter is not one of the maintainers, a manual approval request is created. The workflow pauses until an approver approves or denies the benchmark run by commenting appropriate word on the issue.
+    - The issue for approval request is auto-closed once the approver is done adding appropriate comment
+
+4. **Build and Assemble OpenSearch:**
+    - Builds and assembles (x64-linux tar) the OpenSearch distribution from the pull request code changes.
+
+5. **Upload to S3:**
+    - Configures AWS credentials and uploads the assembled OpenSearch distribution to an S3 bucket for further use in benchmarking.
+    - The S3 bucket is fronted by cloudfront to only allow downloads.
+    - The lifecycle policy on the S3 bucket will delete the uploaded artifacts after 30-days.
+
+6. **Trigger Jenkins Workflow:**
+    - Triggers a Jenkins workflow to run the benchmark tests using a webhook token.
+
+7. **Update Pull Request with Job URL:**
+    - Posts a comment on the pull request with the URL of the Jenkins job. The final benchmark results will be posted once the job completes.
+    - To learn about how benchmark job works see https://github.com/opensearch-project/opensearch-build/tree/main/src/test_workflow#benchmarking-tests
+
+## How to Use This Workflow
+
+1. **Ensure `benchmark-config.json` is Up-to-Date:**
+    - The `benchmark-config.json` file should contain valid benchmark configurations with supported major versions and cluster-benchmark configurations.
+
+2. **Add the Workflow to Your Repository:**
+    - Save the workflow YAML file (typically named `benchmark.yml`) in the `.github/workflows` directory of your repository.
+
+3. **Make a Comment to Trigger the Workflow:**
+    - On any pull request issue, make a comment containing the keyword `"run-benchmark-test"` along with the configuration ID. For example:
+      ```json
+      {"run-benchmark-test": "id_1"}
+      ```
+
+4. **Monitor Workflow Progress:**
+    - The workflow will validate the comment, check for approval (if necessary), build the OpenSearch distribution, and trigger the Jenkins job.
+    - A comment will be posted on the pull request with the URL of the Jenkins job. You can monitor the progress and final results there as well.
+
+## Example Comment Format
+
+To run the benchmark with configuration ID `id_1`, post the following comment on the pull request issue:
+```json
+{"run-benchmark-test": "id_1"}
+```
+
+## How to add a new benchmark configuration
+
+The benchmark-config.json file accepts the following schema.
+```json
+{
+  "id_<number>": {
+    "description": "Short description of the configuration",
+    "supported_major_versions": ["2", "3"],
+    "cluster-benchmark-configs": {
+      "SINGLE_NODE_CLUSTER": "Use single node cluster for benchmarking, accepted values are \"true\" or \"false\"",
+      "MIN_DISTRIBUTION": "Use OpenSearch min distribution, should always be \"true\"",
+      "MANAGER_NODE_COUNT": "For multi-node cluster tests, number of cluster manager nodes, empty value defaults to 3.",
+      "DATA_NODE_COUNT": "For multi-node cluster tests, number of data nodes, empty value defaults to 2.",
+      "DATA_INSTANCE_TYPE": "EC2 instance type for data node, empty defaults to r5.xlarge.",
+      "DATA_NODE_STORAGE": "Data node ebs block storage size, empty value defaults to 100Gb",
+      "JVM_SYS_PROPS": "A comma-separated list of key=value pairs that will be added to jvm.options as JVM system properties",
+      "ADDITIONAL_CONFIG": "Additional space delimited opensearch.yml config parameters. e.g., `search.concurrent_segment_search.enabled:true`",
+      "TEST_WORKLOAD": "The workload name from OpenSearch Benchmark Workloads. https://github.com/opensearch-project/opensearch-benchmark-workloads. Default is nyc_taxis",
+      "WORKLOAD_PARAMS": "With this parameter you can inject variables into workloads, e.g.{\"number_of_replicas\":\"0\",\"number_of_shards\":\"3\"}. See https://opensearch.org/docs/latest/benchmark/reference/commands/command-flags/#workload-params",
+      "EXCLUDE_TASKS": "Defines a comma-separated list of test procedure tasks not to run. e.g. type:search, see https://opensearch.org/docs/latest/benchmark/reference/commands/command-flags/#exclude-tasks",
+      "INCLUDE_TASKS": "Defines a comma-separated list of test procedure tasks to run. By default, all tasks listed in a test procedure array are run. See https://opensearch.org/docs/latest/benchmark/reference/commands/command-flags/#include-tasks",
+      "TEST_PROCEDURE": "Defines a test procedure to use. e.g., `append-no-conflicts,significant-text`. Uses default if none provided. See https://opensearch.org/docs/latest/benchmark/reference/commands/command-flags/#test-procedure",
+      "CAPTURE_NODE_STAT": "Enable opensearch-benchmark node-stats telemetry to capture system level metrics like cpu, jvm etc., see https://opensearch.org/docs/latest/benchmark/reference/telemetry/#node-stats"
+    },
+    "cluster_configuration": {
+      "size": "Single-Node/Multi-Node",
+      "data_instance_config": "data-instance-config, e.g., 4vCPU, 32G Mem, 16G Heap"
+    }
+  }
+}
+```
+To add a new test configuration that are suitable to your changes please create a new PR to add desired cluster and benchmark configurations.
+
+## How to compare my results against baseline?
+
+Apart from just running benchmarks the user will also be interested in how their change is performing against current OpenSearch distribution with the exactly same cluster and benchmark configurations.
+The user can refer to https://s12d.com/basline-dashboards (WIP) to access baseline data for their workload, this data is generated by our nightly benchmark runs on latest build distribution artifacts for 3.0 and 2.x.
+In the future, we will add the [compare](https://opensearch.org/docs/latest/benchmark/reference/commands/compare/) feature of opensearch-benchmark to run comparison and publish data on the PR as well.
+
+## Notes
+
+- Ensure all required secrets (e.g., `GITHUB_TOKEN`, `UPLOAD_ARCHIVE_ARTIFACT_ROLE`, `ARCHIVE_ARTIFACT_BUCKET_NAME`, `JENKINS_PR_BENCHMARK_GENERIC_WEBHOOK_TOKEN`) are properly set in the repository secrets.
+- The `CODEOWNERS` file should list the GitHub usernames of approvers for the benchmark process.
+
+By following these instructions, repository maintainers can ensure consistent and automated performance benchmarking for all code changes introduced via pull requests.
+
+
diff --git a/modules/analysis-common/src/main/java/org/opensearch/analysis/common/CommonAnalysisModulePlugin.java b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/CommonAnalysisModulePlugin.java
index 8d12af5224aff..1b17d45eab6ff 100644
--- a/modules/analysis-common/src/main/java/org/opensearch/analysis/common/CommonAnalysisModulePlugin.java
+++ b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/CommonAnalysisModulePlugin.java
@@ -75,6 +75,7 @@
 import org.apache.lucene.analysis.eu.BasqueAnalyzer;
 import org.apache.lucene.analysis.fa.PersianAnalyzer;
 import org.apache.lucene.analysis.fa.PersianNormalizationFilter;
+import org.apache.lucene.analysis.fa.PersianStemFilter;
 import org.apache.lucene.analysis.fi.FinnishAnalyzer;
 import org.apache.lucene.analysis.fr.FrenchAnalyzer;
 import org.apache.lucene.analysis.ga.IrishAnalyzer;
@@ -317,6 +318,7 @@ public Map<String, AnalysisProvider<TokenFilterFactory>> getTokenFilters() {
         filters.put("pattern_capture", requiresAnalysisSettings(PatternCaptureGroupTokenFilterFactory::new));
         filters.put("pattern_replace", requiresAnalysisSettings(PatternReplaceTokenFilterFactory::new));
         filters.put("persian_normalization", PersianNormalizationFilterFactory::new);
+        filters.put("persian_stem", PersianStemTokenFilterFactory::new);
         filters.put("porter_stem", PorterStemTokenFilterFactory::new);
         filters.put(
             "predicate_token_filter",
@@ -560,6 +562,7 @@ public List<PreConfiguredTokenFilter> getPreConfiguredTokenFilters() {
             );
         }));
         filters.add(PreConfiguredTokenFilter.singleton("persian_normalization", true, PersianNormalizationFilter::new));
+        filters.add(PreConfiguredTokenFilter.singleton("persian_stem", true, PersianStemFilter::new));
         filters.add(PreConfiguredTokenFilter.singleton("porter_stem", false, PorterStemFilter::new));
         filters.add(PreConfiguredTokenFilter.singleton("reverse", false, ReverseStringFilter::new));
         filters.add(PreConfiguredTokenFilter.singleton("russian_stem", false, input -> new SnowballFilter(input, "Russian")));
diff --git a/modules/analysis-common/src/main/java/org/opensearch/analysis/common/PersianStemTokenFilterFactory.java b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/PersianStemTokenFilterFactory.java
new file mode 100644
index 0000000000000..afe8058343e17
--- /dev/null
+++ b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/PersianStemTokenFilterFactory.java
@@ -0,0 +1,52 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.analysis.common;
+
+import org.apache.lucene.analysis.TokenStream;
+import org.apache.lucene.analysis.fa.PersianStemFilter;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.env.Environment;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.analysis.AbstractTokenFilterFactory;
+
+public class PersianStemTokenFilterFactory extends AbstractTokenFilterFactory {
+
+    PersianStemTokenFilterFactory(IndexSettings indexSettings, Environment environment, String name, Settings settings) {
+        super(indexSettings, name, settings);
+    }
+
+    @Override
+    public TokenStream create(TokenStream tokenStream) {
+        return new PersianStemFilter(tokenStream);
+    }
+}
diff --git a/modules/analysis-common/src/main/java/org/opensearch/analysis/common/StemmerTokenFilterFactory.java b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/StemmerTokenFilterFactory.java
index 5506626e40da0..e81f3c6cc09cc 100644
--- a/modules/analysis-common/src/main/java/org/opensearch/analysis/common/StemmerTokenFilterFactory.java
+++ b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/StemmerTokenFilterFactory.java
@@ -47,6 +47,7 @@
 import org.apache.lucene.analysis.en.KStemFilter;
 import org.apache.lucene.analysis.en.PorterStemFilter;
 import org.apache.lucene.analysis.es.SpanishLightStemFilter;
+import org.apache.lucene.analysis.fa.PersianStemFilter;
 import org.apache.lucene.analysis.fi.FinnishLightStemFilter;
 import org.apache.lucene.analysis.fr.FrenchLightStemFilter;
 import org.apache.lucene.analysis.fr.FrenchMinimalStemFilter;
@@ -239,6 +240,8 @@ public TokenStream create(TokenStream tokenStream) {
                 return new NorwegianLightStemFilter(tokenStream, NorwegianLightStemmer.NYNORSK);
             } else if ("minimal_nynorsk".equalsIgnoreCase(language) || "minimalNynorsk".equalsIgnoreCase(language)) {
                 return new NorwegianMinimalStemFilter(tokenStream, NorwegianLightStemmer.NYNORSK);
+            } else if ("persian".equalsIgnoreCase(language)) {
+                return new PersianStemFilter(tokenStream);
 
                 // Portuguese stemmers
             } else if ("portuguese".equalsIgnoreCase(language)) {
diff --git a/modules/analysis-common/src/test/java/org/opensearch/analysis/common/CommonAnalysisFactoryTests.java b/modules/analysis-common/src/test/java/org/opensearch/analysis/common/CommonAnalysisFactoryTests.java
index 11713f52f5b18..7e3140f8bcba3 100644
--- a/modules/analysis-common/src/test/java/org/opensearch/analysis/common/CommonAnalysisFactoryTests.java
+++ b/modules/analysis-common/src/test/java/org/opensearch/analysis/common/CommonAnalysisFactoryTests.java
@@ -158,6 +158,7 @@ protected Map<String, Class<?>> getTokenFilters() {
         filters.put("brazilianstem", BrazilianStemTokenFilterFactory.class);
         filters.put("czechstem", CzechStemTokenFilterFactory.class);
         filters.put("germanstem", GermanStemTokenFilterFactory.class);
+        filters.put("persianstem", PersianStemTokenFilterFactory.class);
         filters.put("telugunormalization", TeluguNormalizationFilterFactory.class);
         filters.put("telugustem", TeluguStemFilterFactory.class);
         // this filter is not exposed and should only be used internally
@@ -220,6 +221,7 @@ protected Map<String, Class<?>> getPreConfiguredTokenFilters() {
         filters.put("ngram", null);
         filters.put("nGram", null);
         filters.put("persian_normalization", null);
+        filters.put("persian_stem", null);
         filters.put("porter_stem", null);
         filters.put("reverse", ReverseStringFilterFactory.class);
         filters.put("russian_stem", SnowballPorterFilterFactory.class);
diff --git a/modules/analysis-common/src/yamlRestTest/resources/rest-api-spec/test/analysis-common/40_token_filters.yml b/modules/analysis-common/src/yamlRestTest/resources/rest-api-spec/test/analysis-common/40_token_filters.yml
index 802c79c780689..c6b075571f221 100644
--- a/modules/analysis-common/src/yamlRestTest/resources/rest-api-spec/test/analysis-common/40_token_filters.yml
+++ b/modules/analysis-common/src/yamlRestTest/resources/rest-api-spec/test/analysis-common/40_token_filters.yml
@@ -1781,6 +1781,37 @@
     - length: { tokens: 1 }
     - match:  { tokens.0.token: abschliess }
 
+---
+"persian_stem":
+  - do:
+      indices.create:
+        index: test
+        body:
+          settings:
+            analysis:
+              filter:
+                my_persian_stem:
+                  type: persian_stem
+  - do:
+      indices.analyze:
+        index: test
+        body:
+          text: جامدات
+          tokenizer: keyword
+          filter:    [my_persian_stem]
+  - length: { tokens: 1 }
+  - match:  { tokens.0.token: جامد }
+
+  # Test pre-configured token filter too:
+  - do:
+      indices.analyze:
+        body:
+          text: جامدات
+          tokenizer: keyword
+          filter:    [persian_stem]
+  - length: { tokens: 1 }
+  - match:  { tokens.0.token: جامد }
+
 ---
 "russian_stem":
     - do:
diff --git a/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/70_bulk.yml b/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/70_bulk.yml
index edb7b77eb8d28..47cc80d6df310 100644
--- a/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/70_bulk.yml
+++ b/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/70_bulk.yml
@@ -41,6 +41,10 @@ teardown:
       ingest.delete_pipeline:
         id: "pipeline2"
         ignore: 404
+  - do:
+      indices.delete_index_template:
+        name: test_index_template_for_bulk
+        ignore: 404
 
 ---
 "Test bulk request without default pipeline":
@@ -168,47 +172,42 @@ teardown:
         id: test_id3
   - match: { _source: {"f1": "v2", "f2": 47, "field1": "value1"}}
 
+# related issue: https://github.com/opensearch-project/OpenSearch/issues/12888
 ---
-"Test bulk API with batch enabled happy case":
+"Test bulk upsert honors default_pipeline and final_pipeline when the auto-created index matches with the index template":
   - skip:
-      version: " - 2.13.99"
-      reason: "Added in 2.14.0"
+      version: " - 2.15.99"
+      reason: "fixed in 2.16.0"
+  - do:
+      indices.put_index_template:
+        name: test_for_bulk_upsert_index_template
+        body:
+          index_patterns: test_bulk_upsert_*
+          template:
+            settings:
+              number_of_shards:   1
+              number_of_replicas: 0
+              default_pipeline: pipeline1
+              final_pipeline: pipeline2
 
   - do:
       bulk:
         refresh: true
-        batch_size: 2
-        pipeline: "pipeline1"
         body:
-          - '{"index": {"_index": "test_index", "_id": "test_id1"}}'
-          - '{"text": "text1"}'
-          - '{"index": {"_index": "test_index", "_id": "test_id2"}}'
-          - '{"text": "text2"}'
-          - '{"index": {"_index": "test_index", "_id": "test_id3"}}'
-          - '{"text": "text3"}'
-          - '{"index": {"_index": "test_index", "_id": "test_id4"}}'
-          - '{"text": "text4"}'
-          - '{"index": {"_index": "test_index", "_id": "test_id5", "pipeline": "pipeline2"}}'
-          - '{"text": "text5"}'
-          - '{"index": {"_index": "test_index", "_id": "test_id6", "pipeline": "pipeline2"}}'
-          - '{"text": "text6"}'
+          - '{"update": {"_index": "test_bulk_upsert_index", "_id": "test_id3"}}'
+          - '{"upsert": {"f1": "v2", "f2": 47}, "doc": {"x": 1}}'
 
   - match: { errors: false }
+  - match: { items.0.update.result: created }
 
   - do:
       get:
-        index: test_index
-        id: test_id5
-  - match: { _source: {"text": "text5", "field2": "value2"}}
-
-  - do:
-      get:
-        index: test_index
+        index: test_bulk_upsert_index
         id: test_id3
-  - match: { _source: { "text": "text3", "field1": "value1" } }
+  - match: { _source: {"f1": "v2", "f2": 47, "field1": "value1", "field2": "value2"}}
 
 ---
-"Test bulk API with batch_size missing":
+"Test bulk API with default batch size":
   - skip:
       version: " - 2.13.99"
       reason: "Added in 2.14.0"
@@ -222,20 +221,28 @@ teardown:
           - '{"text": "text1"}'
           - '{"index": {"_index": "test_index", "_id": "test_id2"}}'
           - '{"text": "text2"}'
+          - '{"index": {"_index": "test_index", "_id": "test_id3"}}'
+          - '{"text": "text3"}'
+          - '{"index": {"_index": "test_index", "_id": "test_id4"}}'
+          - '{"text": "text4"}'
+          - '{"index": {"_index": "test_index", "_id": "test_id5", "pipeline": "pipeline2"}}'
+          - '{"text": "text5"}'
+          - '{"index": {"_index": "test_index", "_id": "test_id6", "pipeline": "pipeline2"}}'
+          - '{"text": "text6"}'
 
   - match: { errors: false }
 
   - do:
       get:
         index: test_index
-        id: test_id1
-  - match: { _source: { "text": "text1", "field1": "value1" } }
+        id: test_id5
+  - match: { _source: {"text": "text5", "field2": "value2"}}
 
   - do:
       get:
         index: test_index
-        id: test_id2
-  - match: { _source: { "text": "text2", "field1": "value1" } }
+        id: test_id3
+  - match: { _source: { "text": "text3", "field1": "value1" } }
 
 ---
 "Test bulk API with invalid batch_size":
diff --git a/modules/percolator/src/yamlRestTest/resources/rest-api-spec/test/10_basic.yml b/modules/percolator/src/yamlRestTest/resources/rest-api-spec/test/10_basic.yml
index 35ebb2b099139..61f79326dab06 100644
--- a/modules/percolator/src/yamlRestTest/resources/rest-api-spec/test/10_basic.yml
+++ b/modules/percolator/src/yamlRestTest/resources/rest-api-spec/test/10_basic.yml
@@ -83,3 +83,48 @@
                 index: documents_index
                 id: some_id
   - match:  { responses.0.hits.total:     1  }
+
+  - do:
+      catch: bad_request
+      index:
+        index: queries_index
+        body:
+          query:
+            query_string:
+              query: "unmapped: *"
+
+  - do:
+      catch: bad_request
+      index:
+        index: queries_index
+        body:
+          query:
+            query_string:
+              query: "_exists_: unmappedField"
+
+  - do:
+        catch: bad_request
+        index:
+          index: queries_index
+          body:
+            query:
+              query_string:
+                query: "unmappedField: <100"
+
+  - do:
+      catch: bad_request
+      index:
+        index: queries_index
+        body:
+          query:
+            query_string:
+              query: "unmappedField: test~"
+
+  - do:
+      catch: bad_request
+      index:
+        index: queries_index
+        body:
+          query:
+            query_string:
+              query: "unmappedField: test*"
diff --git a/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SearchPipelineCommonModulePlugin.java b/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SearchPipelineCommonModulePlugin.java
index 1574621a8200e..2a2de9debb9d9 100644
--- a/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SearchPipelineCommonModulePlugin.java
+++ b/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SearchPipelineCommonModulePlugin.java
@@ -96,7 +96,9 @@ public Map<String, Processor.Factory<SearchResponseProcessor>> getResponseProces
                 TruncateHitsResponseProcessor.TYPE,
                 new TruncateHitsResponseProcessor.Factory(),
                 CollapseResponseProcessor.TYPE,
-                new CollapseResponseProcessor.Factory()
+                new CollapseResponseProcessor.Factory(),
+                SortResponseProcessor.TYPE,
+                new SortResponseProcessor.Factory()
             )
         );
     }
diff --git a/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SortResponseProcessor.java b/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SortResponseProcessor.java
new file mode 100644
index 0000000000000..e0bfd38b26376
--- /dev/null
+++ b/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SortResponseProcessor.java
@@ -0,0 +1,209 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.pipeline.common;
+
+import org.opensearch.action.search.SearchRequest;
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.document.DocumentField;
+import org.opensearch.common.xcontent.XContentHelper;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.xcontent.MediaType;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.ingest.ConfigurationUtils;
+import org.opensearch.search.SearchHit;
+import org.opensearch.search.pipeline.AbstractProcessor;
+import org.opensearch.search.pipeline.Processor;
+import org.opensearch.search.pipeline.SearchResponseProcessor;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * Processor that sorts an array of items.
+ * Throws exception is the specified field is not an array.
+ */
+public class SortResponseProcessor extends AbstractProcessor implements SearchResponseProcessor {
+    /** Key to reference this processor type from a search pipeline. */
+    public static final String TYPE = "sort";
+    /** Key defining the array field to be sorted. */
+    public static final String SORT_FIELD = "field";
+    /** Optional key defining the sort order. */
+    public static final String SORT_ORDER = "order";
+    /** Optional key to put the sorted values in a different field. */
+    public static final String TARGET_FIELD = "target_field";
+    /** Default sort order if not specified */
+    public static final String DEFAULT_ORDER = "asc";
+
+    /** Enum defining how elements will be sorted */
+    public enum SortOrder {
+        /** Sort in ascending (natural) order */
+        ASCENDING("asc"),
+        /** Sort in descending (reverse) order */
+        DESCENDING("desc");
+
+        private final String direction;
+
+        SortOrder(String direction) {
+            this.direction = direction;
+        }
+
+        @Override
+        public String toString() {
+            return this.direction;
+        }
+
+        /**
+         * Converts the string representation of the enum value to the enum.
+         * @param value A string ("asc" or "desc")
+         * @return the corresponding enum value
+         */
+        public static SortOrder fromString(String value) {
+            if (value == null) {
+                throw new IllegalArgumentException("Sort direction cannot be null");
+            }
+
+            if (value.equals(ASCENDING.toString())) {
+                return ASCENDING;
+            } else if (value.equals(DESCENDING.toString())) {
+                return DESCENDING;
+            }
+            throw new IllegalArgumentException("Sort direction [" + value + "] not recognized." + " Valid values are: [asc, desc]");
+        }
+    }
+
+    private final String sortField;
+    private final SortOrder sortOrder;
+    private final String targetField;
+
+    SortResponseProcessor(
+        String tag,
+        String description,
+        boolean ignoreFailure,
+        String sortField,
+        SortOrder sortOrder,
+        String targetField
+    ) {
+        super(tag, description, ignoreFailure);
+        this.sortField = Objects.requireNonNull(sortField);
+        this.sortOrder = Objects.requireNonNull(sortOrder);
+        this.targetField = targetField == null ? sortField : targetField;
+    }
+
+    /**
+     * Getter function for sortField
+     * @return sortField
+     */
+    public String getSortField() {
+        return sortField;
+    }
+
+    /**
+     * Getter function for targetField
+     * @return targetField
+     */
+    public String getTargetField() {
+        return targetField;
+    }
+
+    /**
+     * Getter function for sortOrder
+     * @return sortOrder
+     */
+    public SortOrder getSortOrder() {
+        return sortOrder;
+    }
+
+    @Override
+    public String getType() {
+        return TYPE;
+    }
+
+    @Override
+    public SearchResponse processResponse(SearchRequest request, SearchResponse response) throws Exception {
+        SearchHit[] hits = response.getHits().getHits();
+        for (SearchHit hit : hits) {
+            Map<String, DocumentField> fields = hit.getFields();
+            if (fields.containsKey(sortField)) {
+                DocumentField docField = hit.getFields().get(sortField);
+                if (docField == null) {
+                    throw new IllegalArgumentException("field [" + sortField + "] is null, cannot sort.");
+                }
+                hit.setDocumentField(targetField, new DocumentField(targetField, getSortedValues(docField.getValues())));
+            }
+            if (hit.hasSource()) {
+                BytesReference sourceRef = hit.getSourceRef();
+                Tuple<? extends MediaType, Map<String, Object>> typeAndSourceMap = XContentHelper.convertToMap(
+                    sourceRef,
+                    false,
+                    (MediaType) null
+                );
+
+                Map<String, Object> sourceAsMap = typeAndSourceMap.v2();
+                if (sourceAsMap.containsKey(sortField)) {
+                    Object val = sourceAsMap.get(sortField);
+                    if (val instanceof List) {
+                        @SuppressWarnings("unchecked")
+                        List<Object> listVal = (List<Object>) val;
+                        sourceAsMap.put(targetField, getSortedValues(listVal));
+                    }
+                    XContentBuilder builder = XContentBuilder.builder(typeAndSourceMap.v1().xContent());
+                    builder.map(sourceAsMap);
+                    hit.sourceRef(BytesReference.bytes(builder));
+                }
+            }
+        }
+        return response;
+    }
+
+    private List<Object> getSortedValues(List<Object> values) {
+        return values.stream()
+            .map(this::downcastToComparable)
+            .sorted(sortOrder.equals(SortOrder.ASCENDING) ? Comparator.naturalOrder() : Comparator.reverseOrder())
+            .collect(Collectors.toList());
+    }
+
+    @SuppressWarnings("unchecked")
+    private Comparable<Object> downcastToComparable(Object obj) {
+        if (obj instanceof Comparable) {
+            return (Comparable<Object>) obj;
+        } else if (obj == null) {
+            throw new IllegalArgumentException("field [" + sortField + "] contains a null value.]");
+        } else {
+            throw new IllegalArgumentException("field [" + sortField + "] of type [" + obj.getClass().getName() + "] is not comparable.]");
+        }
+    }
+
+    static class Factory implements Processor.Factory<SearchResponseProcessor> {
+
+        @Override
+        public SortResponseProcessor create(
+            Map<String, Processor.Factory<SearchResponseProcessor>> processorFactories,
+            String tag,
+            String description,
+            boolean ignoreFailure,
+            Map<String, Object> config,
+            PipelineContext pipelineContext
+        ) {
+            String sortField = ConfigurationUtils.readStringProperty(TYPE, tag, config, SORT_FIELD);
+            String targetField = ConfigurationUtils.readStringProperty(TYPE, tag, config, TARGET_FIELD, sortField);
+            try {
+                SortOrder sortOrder = SortOrder.fromString(
+                    ConfigurationUtils.readStringProperty(TYPE, tag, config, SORT_ORDER, DEFAULT_ORDER)
+                );
+                return new SortResponseProcessor(tag, description, ignoreFailure, sortField, sortOrder, targetField);
+            } catch (IllegalArgumentException e) {
+                throw ConfigurationUtils.newConfigurationException(TYPE, tag, SORT_ORDER, e.getMessage());
+            }
+        }
+    }
+}
diff --git a/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SplitResponseProcessor.java b/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SplitResponseProcessor.java
new file mode 100644
index 0000000000000..bb3db4d9bc2c1
--- /dev/null
+++ b/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SplitResponseProcessor.java
@@ -0,0 +1,162 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.pipeline.common;
+
+import org.opensearch.action.search.SearchRequest;
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.document.DocumentField;
+import org.opensearch.common.xcontent.XContentHelper;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.xcontent.MediaType;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.ingest.ConfigurationUtils;
+import org.opensearch.search.SearchHit;
+import org.opensearch.search.pipeline.AbstractProcessor;
+import org.opensearch.search.pipeline.Processor;
+import org.opensearch.search.pipeline.SearchResponseProcessor;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Processor that sorts an array of items.
+ * Throws exception is the specified field is not an array.
+ */
+public class SplitResponseProcessor extends AbstractProcessor implements SearchResponseProcessor {
+    /** Key to reference this processor type from a search pipeline. */
+    public static final String TYPE = "split";
+    /** Key defining the string field to be split. */
+    public static final String SPLIT_FIELD = "field";
+    /** Key defining the delimiter used to split the string. This can be a regular expression pattern. */
+    public static final String SEPARATOR = "separator";
+    /** Optional key for handling empty trailing fields. */
+    public static final String PRESERVE_TRAILING = "preserve_trailing";
+    /** Optional key to put the split values in a different field. */
+    public static final String TARGET_FIELD = "target_field";
+
+    private final String splitField;
+    private final String separator;
+    private final boolean preserveTrailing;
+    private final String targetField;
+
+    SplitResponseProcessor(
+        String tag,
+        String description,
+        boolean ignoreFailure,
+        String splitField,
+        String separator,
+        boolean preserveTrailing,
+        String targetField
+    ) {
+        super(tag, description, ignoreFailure);
+        this.splitField = Objects.requireNonNull(splitField);
+        this.separator = Objects.requireNonNull(separator);
+        this.preserveTrailing = preserveTrailing;
+        this.targetField = targetField == null ? splitField : targetField;
+    }
+
+    /**
+     * Getter function for splitField
+     * @return sortField
+     */
+    public String getSplitField() {
+        return splitField;
+    }
+
+    /**
+     * Getter function for separator
+     * @return separator
+     */
+    public String getSeparator() {
+        return separator;
+    }
+
+    /**
+     * Getter function for preserveTrailing
+     * @return preserveTrailing;
+     */
+    public boolean isPreserveTrailing() {
+        return preserveTrailing;
+    }
+
+    /**
+     * Getter function for targetField
+     * @return targetField
+     */
+    public String getTargetField() {
+        return targetField;
+    }
+
+    @Override
+    public String getType() {
+        return TYPE;
+    }
+
+    @Override
+    public SearchResponse processResponse(SearchRequest request, SearchResponse response) throws Exception {
+        SearchHit[] hits = response.getHits().getHits();
+        for (SearchHit hit : hits) {
+            Map<String, DocumentField> fields = hit.getFields();
+            if (fields.containsKey(splitField)) {
+                DocumentField docField = hit.getFields().get(splitField);
+                if (docField == null) {
+                    throw new IllegalArgumentException("field [" + splitField + "] is null, cannot split.");
+                }
+                Object val = docField.getValue();
+                if (!(val instanceof String)) {
+                    throw new IllegalArgumentException("field [" + splitField + "] is not a string, cannot split");
+                }
+                Object[] strings = ((String) val).split(separator, preserveTrailing ? -1 : 0);
+                hit.setDocumentField(targetField, new DocumentField(targetField, Arrays.asList(strings)));
+            }
+            if (hit.hasSource()) {
+                BytesReference sourceRef = hit.getSourceRef();
+                Tuple<? extends MediaType, Map<String, Object>> typeAndSourceMap = XContentHelper.convertToMap(
+                    sourceRef,
+                    false,
+                    (MediaType) null
+                );
+
+                Map<String, Object> sourceAsMap = typeAndSourceMap.v2();
+                if (sourceAsMap.containsKey(splitField)) {
+                    Object val = sourceAsMap.get(splitField);
+                    if (val instanceof String) {
+                        Object[] strings = ((String) val).split(separator, preserveTrailing ? -1 : 0);
+                        sourceAsMap.put(targetField, Arrays.asList(strings));
+                    }
+                    XContentBuilder builder = XContentBuilder.builder(typeAndSourceMap.v1().xContent());
+                    builder.map(sourceAsMap);
+                    hit.sourceRef(BytesReference.bytes(builder));
+                }
+            }
+        }
+        return response;
+    }
+
+    static class Factory implements Processor.Factory<SearchResponseProcessor> {
+
+        @Override
+        public SplitResponseProcessor create(
+            Map<String, Processor.Factory<SearchResponseProcessor>> processorFactories,
+            String tag,
+            String description,
+            boolean ignoreFailure,
+            Map<String, Object> config,
+            PipelineContext pipelineContext
+        ) {
+            String splitField = ConfigurationUtils.readStringProperty(TYPE, tag, config, SPLIT_FIELD);
+            String separator = ConfigurationUtils.readStringProperty(TYPE, tag, config, SEPARATOR);
+            boolean preserveTrailing = ConfigurationUtils.readBooleanProperty(TYPE, tag, config, PRESERVE_TRAILING, false);
+            String targetField = ConfigurationUtils.readStringProperty(TYPE, tag, config, TARGET_FIELD, splitField);
+            return new SplitResponseProcessor(tag, description, ignoreFailure, splitField, separator, preserveTrailing, targetField);
+        }
+    }
+}
diff --git a/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SearchPipelineCommonModulePluginTests.java b/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SearchPipelineCommonModulePluginTests.java
index 519468ebe17ff..404842742629c 100644
--- a/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SearchPipelineCommonModulePluginTests.java
+++ b/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SearchPipelineCommonModulePluginTests.java
@@ -82,7 +82,7 @@ public void testAllowlistNotSpecified() throws IOException {
         try (SearchPipelineCommonModulePlugin plugin = new SearchPipelineCommonModulePlugin()) {
             assertEquals(Set.of("oversample", "filter_query", "script"), plugin.getRequestProcessors(createParameters(settings)).keySet());
             assertEquals(
-                Set.of("rename_field", "truncate_hits", "collapse"),
+                Set.of("rename_field", "truncate_hits", "collapse", "sort"),
                 plugin.getResponseProcessors(createParameters(settings)).keySet()
             );
             assertEquals(Set.of(), plugin.getSearchPhaseResultsProcessors(createParameters(settings)).keySet());
diff --git a/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SortResponseProcessorTests.java b/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SortResponseProcessorTests.java
new file mode 100644
index 0000000000000..c18c6b34b05d1
--- /dev/null
+++ b/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SortResponseProcessorTests.java
@@ -0,0 +1,230 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a.java
+ * compatible open source license.
+ */
+
+package org.opensearch.search.pipeline.common;
+
+import org.apache.lucene.search.TotalHits;
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.action.search.SearchRequest;
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.action.search.SearchResponseSections;
+import org.opensearch.common.document.DocumentField;
+import org.opensearch.core.common.bytes.BytesArray;
+import org.opensearch.index.query.QueryBuilder;
+import org.opensearch.index.query.TermQueryBuilder;
+import org.opensearch.ingest.RandomDocumentPicks;
+import org.opensearch.search.SearchHit;
+import org.opensearch.search.SearchHits;
+import org.opensearch.search.builder.SearchSourceBuilder;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class SortResponseProcessorTests extends OpenSearchTestCase {
+
+    private static final List<Object> PI = List.of(3, 1, 4, 1, 5, 9, 2, 6);
+    private static final List<Object> E = List.of(2, 7, 1, 8, 2, 8, 1, 8);
+    private static final List<Object> X;
+    static {
+        List<Object> x = new ArrayList<>();
+        x.add(1);
+        x.add(null);
+        x.add(3);
+        X = x;
+    }
+
+    private SearchRequest createDummyRequest() {
+        QueryBuilder query = new TermQueryBuilder("field", "value");
+        SearchSourceBuilder source = new SearchSourceBuilder().query(query);
+        return new SearchRequest().source(source);
+    }
+
+    private SearchResponse createTestResponse() {
+        SearchHit[] hits = new SearchHit[2];
+
+        // one response with source
+        Map<String, DocumentField> piMap = new HashMap<>();
+        piMap.put("digits", new DocumentField("digits", PI));
+        hits[0] = new SearchHit(0, "doc 1", piMap, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"digits\" : " + PI + " }"));
+        hits[0].score((float) Math.PI);
+
+        // one without source
+        Map<String, DocumentField> eMap = new HashMap<>();
+        eMap.put("digits", new DocumentField("digits", E));
+        hits[1] = new SearchHit(1, "doc 2", eMap, Collections.emptyMap());
+        hits[1].score((float) Math.E);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(2, TotalHits.Relation.EQUAL_TO), 2);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    private SearchResponse createTestResponseNullField() {
+        SearchHit[] hits = new SearchHit[1];
+
+        Map<String, DocumentField> map = new HashMap<>();
+        map.put("digits", null);
+        hits[0] = new SearchHit(0, "doc 1", map, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"digits\" : null }"));
+        hits[0].score((float) Math.PI);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(1, TotalHits.Relation.EQUAL_TO), 1);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    private SearchResponse createTestResponseNullListEntry() {
+        SearchHit[] hits = new SearchHit[1];
+
+        Map<String, DocumentField> xMap = new HashMap<>();
+        xMap.put("digits", new DocumentField("digits", X));
+        hits[0] = new SearchHit(0, "doc 1", xMap, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"digits\" : " + X + " }"));
+        hits[0].score((float) Math.PI);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(1, TotalHits.Relation.EQUAL_TO), 1);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    private SearchResponse createTestResponseNotComparable() {
+        SearchHit[] hits = new SearchHit[1];
+
+        Map<String, DocumentField> piMap = new HashMap<>();
+        piMap.put("maps", new DocumentField("maps", List.of(Map.of("foo", "I'm incomparable!"))));
+        hits[0] = new SearchHit(0, "doc 1", piMap, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"maps\" : [{ \"foo\" : \"I'm incomparable!\"}]] }"));
+        hits[0].score((float) Math.PI);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(1, TotalHits.Relation.EQUAL_TO), 1);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    public void testSortResponse() throws Exception {
+        SearchRequest request = createDummyRequest();
+
+        SortResponseProcessor sortResponseProcessor = new SortResponseProcessor(
+            null,
+            null,
+            false,
+            "digits",
+            SortResponseProcessor.SortOrder.ASCENDING,
+            "sorted"
+        );
+        SearchResponse response = createTestResponse();
+        SearchResponse sortResponse = sortResponseProcessor.processResponse(request, response);
+
+        assertEquals(response.getHits(), sortResponse.getHits());
+
+        assertEquals(PI, sortResponse.getHits().getHits()[0].field("digits").getValues());
+        assertEquals(List.of(1, 1, 2, 3, 4, 5, 6, 9), sortResponse.getHits().getHits()[0].field("sorted").getValues());
+        Map<String, Object> map = sortResponse.getHits().getHits()[0].getSourceAsMap();
+        assertNotNull(map);
+        assertEquals(List.of(1, 1, 2, 3, 4, 5, 6, 9), map.get("sorted"));
+
+        assertEquals(E, sortResponse.getHits().getHits()[1].field("digits").getValues());
+        assertEquals(List.of(1, 1, 2, 2, 7, 8, 8, 8), sortResponse.getHits().getHits()[1].field("sorted").getValues());
+        assertNull(sortResponse.getHits().getHits()[1].getSourceAsMap());
+    }
+
+    public void testSortResponseSameField() throws Exception {
+        SearchRequest request = createDummyRequest();
+
+        SortResponseProcessor sortResponseProcessor = new SortResponseProcessor(
+            null,
+            null,
+            false,
+            "digits",
+            SortResponseProcessor.SortOrder.DESCENDING,
+            null
+        );
+        SearchResponse response = createTestResponse();
+        SearchResponse sortResponse = sortResponseProcessor.processResponse(request, response);
+
+        assertEquals(response.getHits(), sortResponse.getHits());
+        assertEquals(List.of(9, 6, 5, 4, 3, 2, 1, 1), sortResponse.getHits().getHits()[0].field("digits").getValues());
+        assertEquals(List.of(8, 8, 8, 7, 2, 2, 1, 1), sortResponse.getHits().getHits()[1].field("digits").getValues());
+    }
+
+    public void testSortResponseNullListEntry() {
+        SearchRequest request = createDummyRequest();
+
+        SortResponseProcessor sortResponseProcessor = new SortResponseProcessor(
+            null,
+            null,
+            false,
+            "digits",
+            SortResponseProcessor.SortOrder.ASCENDING,
+            null
+        );
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> sortResponseProcessor.processResponse(request, createTestResponseNullListEntry())
+        );
+    }
+
+    public void testNullField() {
+        SearchRequest request = createDummyRequest();
+
+        SortResponseProcessor sortResponseProcessor = new SortResponseProcessor(
+            null,
+            null,
+            false,
+            "digits",
+            SortResponseProcessor.SortOrder.DESCENDING,
+            null
+        );
+
+        assertThrows(IllegalArgumentException.class, () -> sortResponseProcessor.processResponse(request, createTestResponseNullField()));
+    }
+
+    public void testNotComparableField() {
+        SearchRequest request = createDummyRequest();
+
+        SortResponseProcessor sortResponseProcessor = new SortResponseProcessor(
+            null,
+            null,
+            false,
+            "maps",
+            SortResponseProcessor.SortOrder.ASCENDING,
+            null
+        );
+
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> sortResponseProcessor.processResponse(request, createTestResponseNotComparable())
+        );
+    }
+
+    public void testFactory() {
+        String sortField = RandomDocumentPicks.randomFieldName(random());
+        String targetField = RandomDocumentPicks.randomFieldName(random());
+        Map<String, Object> config = new HashMap<>();
+        config.put("field", sortField);
+        config.put("order", "desc");
+        config.put("target_field", targetField);
+
+        SortResponseProcessor.Factory factory = new SortResponseProcessor.Factory();
+        SortResponseProcessor processor = factory.create(Collections.emptyMap(), null, null, false, config, null);
+        assertEquals("sort", processor.getType());
+        assertEquals(sortField, processor.getSortField());
+        assertEquals(targetField, processor.getTargetField());
+        assertEquals(SortResponseProcessor.SortOrder.DESCENDING, processor.getSortOrder());
+
+        expectThrows(
+            OpenSearchParseException.class,
+            () -> factory.create(Collections.emptyMap(), null, null, false, Collections.emptyMap(), null)
+        );
+    }
+}
diff --git a/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SplitResponseProcessorTests.java b/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SplitResponseProcessorTests.java
new file mode 100644
index 0000000000000..fcbc8ccf43cff
--- /dev/null
+++ b/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SplitResponseProcessorTests.java
@@ -0,0 +1,213 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a.java
+ * compatible open source license.
+ */
+
+package org.opensearch.search.pipeline.common;
+
+import org.apache.lucene.search.TotalHits;
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.action.search.SearchRequest;
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.action.search.SearchResponseSections;
+import org.opensearch.common.document.DocumentField;
+import org.opensearch.core.common.bytes.BytesArray;
+import org.opensearch.index.query.QueryBuilder;
+import org.opensearch.index.query.TermQueryBuilder;
+import org.opensearch.ingest.RandomDocumentPicks;
+import org.opensearch.search.SearchHit;
+import org.opensearch.search.SearchHits;
+import org.opensearch.search.builder.SearchSourceBuilder;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class SplitResponseProcessorTests extends OpenSearchTestCase {
+
+    private static final String NO_TRAILING = "one,two,three";
+    private static final String TRAILING = "alpha,beta,gamma,";
+    private static final String REGEX_DELIM = "one1two2three";
+
+    private SearchRequest createDummyRequest() {
+        QueryBuilder query = new TermQueryBuilder("field", "value");
+        SearchSourceBuilder source = new SearchSourceBuilder().query(query);
+        return new SearchRequest().source(source);
+    }
+
+    private SearchResponse createTestResponse() {
+        SearchHit[] hits = new SearchHit[2];
+
+        // one response with source
+        Map<String, DocumentField> csvMap = new HashMap<>();
+        csvMap.put("csv", new DocumentField("csv", List.of(NO_TRAILING)));
+        hits[0] = new SearchHit(0, "doc 1", csvMap, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"csv\" : \"" + NO_TRAILING + "\" }"));
+        hits[0].score(1f);
+
+        // one without source
+        csvMap = new HashMap<>();
+        csvMap.put("csv", new DocumentField("csv", List.of(TRAILING)));
+        hits[1] = new SearchHit(1, "doc 2", csvMap, Collections.emptyMap());
+        hits[1].score(2f);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(2, TotalHits.Relation.EQUAL_TO), 2);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    private SearchResponse createTestResponseRegex() {
+        SearchHit[] hits = new SearchHit[1];
+
+        Map<String, DocumentField> dsvMap = new HashMap<>();
+        dsvMap.put("dsv", new DocumentField("dsv", List.of(REGEX_DELIM)));
+        hits[0] = new SearchHit(0, "doc 1", dsvMap, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"dsv\" : \"" + REGEX_DELIM + "\" }"));
+        hits[0].score(1f);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(1, TotalHits.Relation.EQUAL_TO), 1);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    private SearchResponse createTestResponseNullField() {
+        SearchHit[] hits = new SearchHit[1];
+
+        Map<String, DocumentField> map = new HashMap<>();
+        map.put("csv", null);
+        hits[0] = new SearchHit(0, "doc 1", map, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"csv\" : null }"));
+        hits[0].score(1f);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(1, TotalHits.Relation.EQUAL_TO), 1);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    private SearchResponse createTestResponseEmptyList() {
+        SearchHit[] hits = new SearchHit[1];
+
+        Map<String, DocumentField> map = new HashMap<>();
+        map.put("empty", new DocumentField("empty", List.of()));
+        hits[0] = new SearchHit(0, "doc 1", map, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"empty\" : [] }"));
+        hits[0].score(1f);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(1, TotalHits.Relation.EQUAL_TO), 1);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    private SearchResponse createTestResponseNotString() {
+        SearchHit[] hits = new SearchHit[1];
+
+        Map<String, DocumentField> piMap = new HashMap<>();
+        piMap.put("maps", new DocumentField("maps", List.of(Map.of("foo", "I'm the Map!"))));
+        hits[0] = new SearchHit(0, "doc 1", piMap, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"maps\" : [{ \"foo\" : \"I'm the Map!\"}]] }"));
+        hits[0].score(1f);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(1, TotalHits.Relation.EQUAL_TO), 1);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    public void testSplitResponse() throws Exception {
+        SearchRequest request = createDummyRequest();
+
+        SplitResponseProcessor splitResponseProcessor = new SplitResponseProcessor(null, null, false, "csv", ",", false, "split");
+        SearchResponse response = createTestResponse();
+        SearchResponse splitResponse = splitResponseProcessor.processResponse(request, response);
+
+        assertEquals(response.getHits(), splitResponse.getHits());
+
+        assertEquals(NO_TRAILING, splitResponse.getHits().getHits()[0].field("csv").getValue());
+        assertEquals(List.of("one", "two", "three"), splitResponse.getHits().getHits()[0].field("split").getValues());
+        Map<String, Object> map = splitResponse.getHits().getHits()[0].getSourceAsMap();
+        assertNotNull(map);
+        assertEquals(List.of("one", "two", "three"), map.get("split"));
+
+        assertEquals(TRAILING, splitResponse.getHits().getHits()[1].field("csv").getValue());
+        assertEquals(List.of("alpha", "beta", "gamma"), splitResponse.getHits().getHits()[1].field("split").getValues());
+        assertNull(splitResponse.getHits().getHits()[1].getSourceAsMap());
+    }
+
+    public void testSplitResponseRegex() throws Exception {
+        SearchRequest request = createDummyRequest();
+
+        SplitResponseProcessor splitResponseProcessor = new SplitResponseProcessor(null, null, false, "dsv", "\\d", false, "split");
+        SearchResponse response = createTestResponseRegex();
+        SearchResponse splitResponse = splitResponseProcessor.processResponse(request, response);
+
+        assertEquals(response.getHits(), splitResponse.getHits());
+
+        assertEquals(REGEX_DELIM, splitResponse.getHits().getHits()[0].field("dsv").getValue());
+        assertEquals(List.of("one", "two", "three"), splitResponse.getHits().getHits()[0].field("split").getValues());
+        Map<String, Object> map = splitResponse.getHits().getHits()[0].getSourceAsMap();
+        assertNotNull(map);
+        assertEquals(List.of("one", "two", "three"), map.get("split"));
+    }
+
+    public void testSplitResponseSameField() throws Exception {
+        SearchRequest request = createDummyRequest();
+
+        SplitResponseProcessor splitResponseProcessor = new SplitResponseProcessor(null, null, false, "csv", ",", true, null);
+        SearchResponse response = createTestResponse();
+        SearchResponse splitResponse = splitResponseProcessor.processResponse(request, response);
+
+        assertEquals(response.getHits(), splitResponse.getHits());
+        assertEquals(List.of("one", "two", "three"), splitResponse.getHits().getHits()[0].field("csv").getValues());
+        assertEquals(List.of("alpha", "beta", "gamma", ""), splitResponse.getHits().getHits()[1].field("csv").getValues());
+    }
+
+    public void testSplitResponseEmptyList() {
+        SearchRequest request = createDummyRequest();
+
+        SplitResponseProcessor splitResponseProcessor = new SplitResponseProcessor(null, null, false, "empty", ",", false, null);
+        assertThrows(IllegalArgumentException.class, () -> splitResponseProcessor.processResponse(request, createTestResponseEmptyList()));
+    }
+
+    public void testNullField() {
+        SearchRequest request = createDummyRequest();
+
+        SplitResponseProcessor splitResponseProcessor = new SplitResponseProcessor(null, null, false, "csv", ",", false, null);
+
+        assertThrows(IllegalArgumentException.class, () -> splitResponseProcessor.processResponse(request, createTestResponseNullField()));
+    }
+
+    public void testNotStringField() {
+        SearchRequest request = createDummyRequest();
+
+        SplitResponseProcessor splitResponseProcessor = new SplitResponseProcessor(null, null, false, "maps", ",", false, null);
+
+        assertThrows(IllegalArgumentException.class, () -> splitResponseProcessor.processResponse(request, createTestResponseNotString()));
+    }
+
+    public void testFactory() {
+        String splitField = RandomDocumentPicks.randomFieldName(random());
+        String targetField = RandomDocumentPicks.randomFieldName(random());
+        Map<String, Object> config = new HashMap<>();
+        config.put("field", splitField);
+        config.put("separator", ",");
+        config.put("preserve_trailing", true);
+        config.put("target_field", targetField);
+
+        SplitResponseProcessor.Factory factory = new SplitResponseProcessor.Factory();
+        SplitResponseProcessor processor = factory.create(Collections.emptyMap(), null, null, false, config, null);
+        assertEquals("split", processor.getType());
+        assertEquals(splitField, processor.getSplitField());
+        assertEquals(",", processor.getSeparator());
+        assertTrue(processor.isPreserveTrailing());
+        assertEquals(targetField, processor.getTargetField());
+
+        expectThrows(
+            OpenSearchParseException.class,
+            () -> factory.create(Collections.emptyMap(), null, null, false, Collections.emptyMap(), null)
+        );
+    }
+}
diff --git a/modules/search-pipeline-common/src/yamlRestTest/resources/rest-api-spec/test/search_pipeline/80_sort_response.yml b/modules/search-pipeline-common/src/yamlRestTest/resources/rest-api-spec/test/search_pipeline/80_sort_response.yml
new file mode 100644
index 0000000000000..c160b550b2a6e
--- /dev/null
+++ b/modules/search-pipeline-common/src/yamlRestTest/resources/rest-api-spec/test/search_pipeline/80_sort_response.yml
@@ -0,0 +1,152 @@
+---
+teardown:
+  - do:
+      search_pipeline.delete:
+        id: "my_pipeline"
+        ignore: 404
+
+---
+"Test sort processor":
+  - do:
+      search_pipeline.put:
+        id: "my_pipeline"
+        body: >
+          {
+            "description": "test pipeline",
+            "response_processors": [
+              {
+                "sort":
+                  {
+                    "field": "a",
+                    "target_field": "b"
+                  }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      search_pipeline.put:
+        id: "my_pipeline_2"
+        body: >
+          {
+            "description": "test pipeline with ignore failure true",
+            "response_processors": [
+              {
+                "sort":
+                  {
+                    "field": "aa",
+                    "ignore_failure": true
+                  }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      search_pipeline.put:
+        id: "my_pipeline_3"
+        body: >
+          {
+            "description": "test pipeline",
+            "response_processors": [
+              {
+                "sort":
+                  {
+                    "field": "a",
+                    "order": "desc",
+                    "target_field": "b"
+                  }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      indices.create:
+        index: test
+
+  - do:
+      indices.put_mapping:
+        index: test
+        body:
+          properties:
+            a:
+              type: integer
+              store: true
+              doc_values: true
+
+  - do:
+      index:
+        index: test
+        id: 1
+        body: {
+          "a": [ 3, 1, 4 ]
+        }
+
+  - do:
+      indices.refresh:
+        index: test
+
+  - do:
+      search:
+        body: { }
+  - match: { hits.total.value: 1 }
+
+  - do:
+      search:
+        index: test
+        search_pipeline: "my_pipeline"
+        body: { }
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._source: { "a": [3, 1, 4], "b": [1, 3, 4] } }
+
+  # Should also work with no search body specified
+  - do:
+      search:
+        index: test
+        search_pipeline: "my_pipeline"
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._source: { "a": [3, 1, 4], "b": [1, 3, 4] } }
+
+  # Pipeline with ignore_failure set to true
+  # Should return while catching error
+  - do:
+      search:
+        index: test
+        search_pipeline: "my_pipeline_2"
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._source: { "a": [3, 1, 4] } }
+
+  # Pipeline with desc sort order
+  - do:
+      search:
+        index: test
+        search_pipeline: "my_pipeline_3"
+        body: { }
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._source: { "a": [3, 1, 4], "b": [4, 3, 1] } }
+
+  # No source, using stored_fields
+  - do:
+      search:
+        index: test
+        search_pipeline: "my_pipeline"
+        body: {
+          "_source": false,
+          "stored_fields": [ "a" ]
+        }
+  - match: { hits.hits.0.fields: { "a": [3, 1, 4], "b": [1, 3, 4] } }
+
+  # No source, using docvalue_fields
+  - do:
+      search:
+        index: test
+        search_pipeline: "my_pipeline_3"
+        body: {
+          "_source": false,
+          "docvalue_fields": [ "a" ]
+        }
+  # a is stored sorted because docvalue_fields is pre-sorted to optimize aggregations
+  # this is poorly documented which makes it really hard to write "expected" values on tests
+  - match: { hits.hits.0.fields: { "a": [1, 3, 4], "b": [4, 3, 1] } }
diff --git a/plugins/cache-ehcache/src/main/java/org/opensearch/cache/store/disk/EhcacheDiskCache.java b/plugins/cache-ehcache/src/main/java/org/opensearch/cache/store/disk/EhcacheDiskCache.java
index b4c62fbf85cb8..4a95b04de3952 100644
--- a/plugins/cache-ehcache/src/main/java/org/opensearch/cache/store/disk/EhcacheDiskCache.java
+++ b/plugins/cache-ehcache/src/main/java/org/opensearch/cache/store/disk/EhcacheDiskCache.java
@@ -60,7 +60,6 @@
 import java.util.function.ToLongBiFunction;
 
 import org.ehcache.Cache;
-import org.ehcache.CachePersistenceException;
 import org.ehcache.PersistentCacheManager;
 import org.ehcache.config.builders.CacheConfigurationBuilder;
 import org.ehcache.config.builders.CacheEventListenerConfigurationBuilder;
@@ -104,8 +103,6 @@ public class EhcacheDiskCache<K, V> implements ICache<K, V> {
     // Unique id associated with this cache.
     private final static String UNIQUE_ID = UUID.randomUUID().toString();
     private final static String THREAD_POOL_ALIAS_PREFIX = "ehcachePool";
-    private final static int MINIMUM_MAX_SIZE_IN_BYTES = 1024 * 100; // 100KB
-
     // A Cache manager can create many caches.
     private final PersistentCacheManager cacheManager;
 
@@ -127,13 +124,18 @@ public class EhcacheDiskCache<K, V> implements ICache<K, V> {
     private final Serializer<K, byte[]> keySerializer;
     private final Serializer<V, byte[]> valueSerializer;
 
+    final static int MINIMUM_MAX_SIZE_IN_BYTES = 1024 * 100; // 100KB
+    final static String CACHE_DATA_CLEANUP_DURING_INITIALIZATION_EXCEPTION = "Failed to delete ehcache disk cache under "
+        + "path: %s during initialization. Please clean this up manually and restart the process";
+
     /**
      * Used in computeIfAbsent to synchronize loading of a given key. This is needed as ehcache doesn't provide a
      * computeIfAbsent method.
      */
     Map<ICacheKey<K>, CompletableFuture<Tuple<ICacheKey<K>, V>>> completableFutureMap = new ConcurrentHashMap<>();
 
-    private EhcacheDiskCache(Builder<K, V> builder) {
+    @SuppressForbidden(reason = "Ehcache uses File.io")
+    EhcacheDiskCache(Builder<K, V> builder) {
         this.keyType = Objects.requireNonNull(builder.keyType, "Key type shouldn't be null");
         this.valueType = Objects.requireNonNull(builder.valueType, "Value type shouldn't be null");
         this.expireAfterAccess = Objects.requireNonNull(builder.getExpireAfterAcess(), "ExpireAfterAccess value shouldn't " + "be null");
@@ -151,6 +153,18 @@ private EhcacheDiskCache(Builder<K, V> builder) {
         if (this.storagePath == null || this.storagePath.isBlank()) {
             throw new IllegalArgumentException("Storage path shouldn't be null or empty");
         }
+        // Delete all the previous disk cache related files/data. We don't persist data between process restart for
+        // now which is why need to do this. Clean up in case there was a non graceful restart and we had older disk
+        // cache data still lying around.
+        Path ehcacheDirectory = Paths.get(this.storagePath);
+        if (Files.exists(ehcacheDirectory)) {
+            try {
+                logger.info("Found older disk cache data lying around during initialization under path: {}", this.storagePath);
+                IOUtils.rm(ehcacheDirectory);
+            } catch (IOException e) {
+                throw new OpenSearchException(String.format(CACHE_DATA_CLEANUP_DURING_INITIALIZATION_EXCEPTION, this.storagePath), e);
+            }
+        }
         if (builder.threadPoolAlias == null || builder.threadPoolAlias.isBlank()) {
             this.threadPoolAlias = THREAD_POOL_ALIAS_PREFIX + "DiskWrite#" + UNIQUE_ID;
         } else {
@@ -175,6 +189,11 @@ private EhcacheDiskCache(Builder<K, V> builder) {
         }
     }
 
+    // Package private for testing
+    PersistentCacheManager getCacheManager() {
+        return this.cacheManager;
+    }
+
     @SuppressWarnings({ "rawtypes" })
     private Cache<ICacheKey, ByteArrayWrapper> buildCache(Duration expireAfterAccess, Builder<K, V> builder) {
         // Creating the cache requires permissions specified in plugin-security.policy
@@ -255,7 +274,7 @@ Map<ICacheKey<K>, CompletableFuture<Tuple<ICacheKey<K>, V>>> getCompletableFutur
     }
 
     @SuppressForbidden(reason = "Ehcache uses File.io")
-    private PersistentCacheManager buildCacheManager() {
+    PersistentCacheManager buildCacheManager() {
         // In case we use multiple ehCaches, we can define this cache manager at a global level.
         // Creating the cache manager also requires permissions specified in plugin-security.policy
         return AccessController.doPrivileged((PrivilegedAction<PersistentCacheManager>) () -> {
@@ -444,20 +463,21 @@ public void refresh() {
     @Override
     @SuppressForbidden(reason = "Ehcache uses File.io")
     public void close() {
-        cacheManager.removeCache(this.diskCacheAlias);
-        cacheManager.close();
         try {
-            cacheManager.destroyCache(this.diskCacheAlias);
-            // Delete all the disk cache related files/data
-            Path ehcacheDirectory = Paths.get(this.storagePath);
-            if (Files.exists(ehcacheDirectory)) {
+            cacheManager.close();
+        } catch (Exception e) {
+            logger.error(() -> new ParameterizedMessage("Exception occurred while trying to close ehcache manager"), e);
+        }
+        // Delete all the disk cache related files/data in case it is present
+        Path ehcacheDirectory = Paths.get(this.storagePath);
+        if (Files.exists(ehcacheDirectory)) {
+            try {
                 IOUtils.rm(ehcacheDirectory);
+            } catch (IOException e) {
+                logger.error(() -> new ParameterizedMessage("Failed to delete ehcache disk cache data under path: {}", this.storagePath));
             }
-        } catch (CachePersistenceException e) {
-            throw new OpenSearchException("Exception occurred while destroying ehcache and associated data", e);
-        } catch (IOException e) {
-            logger.error(() -> new ParameterizedMessage("Failed to delete ehcache disk cache data under path: {}", this.storagePath));
         }
+
     }
 
     /**
diff --git a/plugins/cache-ehcache/src/test/java/org/opensearch/cache/store/disk/EhCacheDiskCacheTests.java b/plugins/cache-ehcache/src/test/java/org/opensearch/cache/store/disk/EhCacheDiskCacheTests.java
index 29551befd3e9f..2bc24227bb513 100644
--- a/plugins/cache-ehcache/src/test/java/org/opensearch/cache/store/disk/EhCacheDiskCacheTests.java
+++ b/plugins/cache-ehcache/src/test/java/org/opensearch/cache/store/disk/EhCacheDiskCacheTests.java
@@ -25,6 +25,7 @@
 import org.opensearch.common.metrics.CounterMetric;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.core.common.bytes.BytesArray;
 import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.core.common.bytes.CompositeBytesReference;
@@ -34,6 +35,8 @@
 import java.io.IOException;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -47,10 +50,17 @@
 import java.util.concurrent.Phaser;
 import java.util.function.ToLongBiFunction;
 
+import org.ehcache.PersistentCacheManager;
+
 import static org.opensearch.cache.EhcacheDiskCacheSettings.DISK_LISTENER_MODE_SYNC_KEY;
 import static org.opensearch.cache.EhcacheDiskCacheSettings.DISK_MAX_SIZE_IN_BYTES_KEY;
 import static org.opensearch.cache.EhcacheDiskCacheSettings.DISK_STORAGE_PATH_KEY;
+import static org.opensearch.cache.store.disk.EhcacheDiskCache.MINIMUM_MAX_SIZE_IN_BYTES;
 import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
 
 @ThreadLeakFilters(filters = { EhcacheThreadLeakFilter.class })
 public class EhCacheDiskCacheTests extends OpenSearchSingleNodeTestCase {
@@ -882,6 +892,289 @@ public void testStatsTrackingDisabled() throws Exception {
         }
     }
 
+    public void testDiskCacheFilesAreClearedUpDuringCloseAndInitialization() throws Exception {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            String path = env.nodePaths()[0].path.toString() + "/request_cache";
+            // Create a dummy file to simulate a scenario where the data is already in the disk cache storage path
+            // beforehand.
+            Files.createDirectory(Path.of(path));
+            Path dummyFilePath = Files.createFile(Path.of(path + "/testing.txt"));
+            assertTrue(Files.exists(dummyFilePath));
+            ICache<String, String> ehcacheTest = new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias("ehcacheTest")
+                .setStoragePath(path)
+                .setIsEventListenerModeSync(true)
+                .setKeyType(String.class)
+                .setValueType(String.class)
+                .setKeySerializer(new StringSerializer())
+                .setDiskCacheAlias("test1")
+                .setValueSerializer(new StringSerializer())
+                .setDimensionNames(List.of(dimensionName))
+                .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                .setThreadPoolAlias("")
+                .setSettings(settings)
+                .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                .setMaximumWeightInBytes(CACHE_SIZE_IN_BYTES)
+                .setRemovalListener(removalListener)
+                .setWeigher(weigher)
+                .setStatsTrackingEnabled(false)
+                .build();
+            int randomKeys = randomIntBetween(10, 100);
+            for (int i = 0; i < randomKeys; i++) {
+                ICacheKey<String> iCacheKey = getICacheKey(UUID.randomUUID().toString());
+                ehcacheTest.put(iCacheKey, UUID.randomUUID().toString());
+                assertEquals(0, ehcacheTest.count()); // Expect count of 0 if NoopCacheStatsHolder is used
+                assertEquals(new ImmutableCacheStats(0, 0, 0, 0, 0), ehcacheTest.stats().getTotalStats());
+            }
+            // Verify that older data was wiped out after initialization
+            assertFalse(Files.exists(dummyFilePath));
+
+            // Verify that there is data present under desired path by explicitly verifying the folder name by prefix
+            // (used from disk cache alias)
+            assertTrue(Files.exists(Path.of(path)));
+            boolean folderExists = Files.walk(Path.of(path))
+                .filter(Files::isDirectory)
+                .anyMatch(path1 -> path1.getFileName().toString().startsWith("test1"));
+            assertTrue(folderExists);
+            ehcacheTest.close();
+            assertFalse(Files.exists(Path.of(path))); // Verify everything is cleared up now after close()
+        }
+    }
+
+    public void testDiskCacheCloseCalledTwiceAndVerifyDiskDataIsCleanedUp() throws Exception {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            String path = env.nodePaths()[0].path.toString() + "/request_cache";
+            ICache<String, String> ehcacheTest = new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias(null)
+                .setStoragePath(path)
+                .setIsEventListenerModeSync(true)
+                .setKeyType(String.class)
+                .setValueType(String.class)
+                .setKeySerializer(new StringSerializer())
+                .setDiskCacheAlias("test1")
+                .setValueSerializer(new StringSerializer())
+                .setDimensionNames(List.of(dimensionName))
+                .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                .setSettings(settings)
+                .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                .setMaximumWeightInBytes(CACHE_SIZE_IN_BYTES)
+                .setRemovalListener(removalListener)
+                .setWeigher(weigher)
+                .setStatsTrackingEnabled(false)
+                .build();
+            int randomKeys = randomIntBetween(10, 100);
+            for (int i = 0; i < randomKeys; i++) {
+                ICacheKey<String> iCacheKey = getICacheKey(UUID.randomUUID().toString());
+                ehcacheTest.put(iCacheKey, UUID.randomUUID().toString());
+                assertEquals(0, ehcacheTest.count()); // Expect count storagePath 0 if NoopCacheStatsHolder is used
+                assertEquals(new ImmutableCacheStats(0, 0, 0, 0, 0), ehcacheTest.stats().getTotalStats());
+            }
+            ehcacheTest.close();
+            assertFalse(Files.exists(Path.of(path))); // Verify everything is cleared up now after close()
+            // Call it again. This will throw an exception.
+            ehcacheTest.close();
+        }
+    }
+
+    public void testDiskCacheCloseAfterCleaningUpFilesManually() throws Exception {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            String path = env.nodePaths()[0].path.toString() + "/request_cache";
+            ICache<String, String> ehcacheTest = new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias(null)
+                .setStoragePath(path)
+                .setIsEventListenerModeSync(true)
+                .setKeyType(String.class)
+                .setValueType(String.class)
+                .setKeySerializer(new StringSerializer())
+                .setDiskCacheAlias("test1")
+                .setValueSerializer(new StringSerializer())
+                .setDimensionNames(List.of(dimensionName))
+                .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                .setSettings(settings)
+                .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                .setMaximumWeightInBytes(CACHE_SIZE_IN_BYTES)
+                .setRemovalListener(removalListener)
+                .setWeigher(weigher)
+                .setStatsTrackingEnabled(false)
+                .build();
+            int randomKeys = randomIntBetween(10, 100);
+            for (int i = 0; i < randomKeys; i++) {
+                ICacheKey<String> iCacheKey = getICacheKey(UUID.randomUUID().toString());
+                ehcacheTest.put(iCacheKey, UUID.randomUUID().toString());
+                assertEquals(0, ehcacheTest.count()); // Expect count storagePath 0 if NoopCacheStatsHolder is used
+                assertEquals(new ImmutableCacheStats(0, 0, 0, 0, 0), ehcacheTest.stats().getTotalStats());
+            }
+            IOUtils.rm(Path.of(path));
+            ehcacheTest.close();
+        }
+    }
+
+    public void testEhcacheDiskCacheWithoutStoragePathDefined() throws Exception {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias("ehcacheTest")
+                    .setIsEventListenerModeSync(true)
+                    .setKeyType(String.class)
+                    .setValueType(String.class)
+                    .setKeySerializer(new StringSerializer())
+                    .setDiskCacheAlias("test1")
+                    .setValueSerializer(new StringSerializer())
+                    .setDimensionNames(List.of(dimensionName))
+                    .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                    .setSettings(settings)
+                    .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                    .setMaximumWeightInBytes(CACHE_SIZE_IN_BYTES)
+                    .setRemovalListener(removalListener)
+                    .setWeigher(weigher)
+                    .setStatsTrackingEnabled(false)
+                    .build()
+            );
+        }
+    }
+
+    public void testEhcacheDiskCacheWithoutStoragePathNull() throws Exception {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias("ehcacheTest")
+                    .setStoragePath(null)
+                    .setIsEventListenerModeSync(true)
+                    .setKeyType(String.class)
+                    .setValueType(String.class)
+                    .setKeySerializer(new StringSerializer())
+                    .setDiskCacheAlias("test1")
+                    .setValueSerializer(new StringSerializer())
+                    .setDimensionNames(List.of(dimensionName))
+                    .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                    .setSettings(settings)
+                    .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                    .setMaximumWeightInBytes(CACHE_SIZE_IN_BYTES)
+                    .setRemovalListener(removalListener)
+                    .setWeigher(weigher)
+                    .setStatsTrackingEnabled(false)
+                    .build()
+            );
+        }
+    }
+
+    public void testEhcacheWithStorageSizeLowerThanMinimumExpected() throws Exception {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias("ehcacheTest")
+                    .setIsEventListenerModeSync(true)
+                    .setKeyType(String.class)
+                    .setValueType(String.class)
+                    .setKeySerializer(new StringSerializer())
+                    .setDiskCacheAlias("test1")
+                    .setValueSerializer(new StringSerializer())
+                    .setDimensionNames(List.of(dimensionName))
+                    .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                    .setSettings(settings)
+                    .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                    .setMaximumWeightInBytes(MINIMUM_MAX_SIZE_IN_BYTES)
+                    .setRemovalListener(removalListener)
+                    .setWeigher(weigher)
+                    .setStatsTrackingEnabled(false)
+                    .build()
+            );
+        }
+    }
+
+    public void testEhcacheWithStorageSizeZero() throws Exception {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias("ehcacheTest")
+                    .setIsEventListenerModeSync(true)
+                    .setKeyType(String.class)
+                    .setValueType(String.class)
+                    .setKeySerializer(new StringSerializer())
+                    .setDiskCacheAlias("test1")
+                    .setValueSerializer(new StringSerializer())
+                    .setDimensionNames(List.of(dimensionName))
+                    .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                    .setSettings(settings)
+                    .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                    .setMaximumWeightInBytes(0)
+                    .setRemovalListener(removalListener)
+                    .setWeigher(weigher)
+                    .setStatsTrackingEnabled(false)
+                    .build()
+            );
+        }
+    }
+
+    public void testEhcacheCloseWithDestroyCacheMethodThrowingException() throws Exception {
+        EhcacheDiskCache<String, String> ehcacheDiskCache = new MockEhcahceDiskCache(createDummyBuilder(null));
+        PersistentCacheManager cacheManager = ehcacheDiskCache.getCacheManager();
+        doNothing().when(cacheManager).removeCache(anyString());
+        doNothing().when(cacheManager).close();
+        doThrow(new RuntimeException("test")).when(cacheManager).destroyCache(anyString());
+        ehcacheDiskCache.close();
+    }
+
+    static class MockEhcahceDiskCache extends EhcacheDiskCache<String, String> {
+
+        public MockEhcahceDiskCache(Builder<String, String> builder) {
+            super(builder);
+        }
+
+        @Override
+        PersistentCacheManager buildCacheManager() {
+            PersistentCacheManager cacheManager = mock(PersistentCacheManager.class);
+            return cacheManager;
+        }
+    }
+
+    private EhcacheDiskCache.Builder<String, String> createDummyBuilder(String storagePath) throws IOException {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            if (storagePath == null || storagePath.isBlank()) {
+                storagePath = env.nodePaths()[0].path.toString() + "/request_cache";
+            }
+            return (EhcacheDiskCache.Builder<String, String>) new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias(
+                "ehcacheTest"
+            )
+                .setIsEventListenerModeSync(true)
+                .setStoragePath(storagePath)
+                .setKeyType(String.class)
+                .setValueType(String.class)
+                .setKeySerializer(new StringSerializer())
+                .setDiskCacheAlias("test1")
+                .setValueSerializer(new StringSerializer())
+                .setDimensionNames(List.of(dimensionName))
+                .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                .setSettings(settings)
+                .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                .setMaximumWeightInBytes(CACHE_SIZE_IN_BYTES)
+                .setRemovalListener(removalListener)
+                .setWeigher(weigher)
+                .setStatsTrackingEnabled(false);
+        }
+    }
+
     private List<String> getRandomDimensions(List<String> dimensionNames) {
         Random rand = Randomness.get();
         int bound = 3;
diff --git a/plugins/repository-azure/build.gradle b/plugins/repository-azure/build.gradle
index 980940e35b0b0..7bd7be1481a2f 100644
--- a/plugins/repository-azure/build.gradle
+++ b/plugins/repository-azure/build.gradle
@@ -61,7 +61,7 @@ dependencies {
   // Start of transitive dependencies for azure-identity
   api 'com.microsoft.azure:msal4j-persistence-extension:1.3.0'
   api "net.java.dev.jna:jna-platform:${versions.jna}"
-  api 'com.microsoft.azure:msal4j:1.16.0'
+  api 'com.microsoft.azure:msal4j:1.16.1'
   api 'com.nimbusds:oauth2-oidc-sdk:11.9.1'
   api 'com.nimbusds:nimbus-jose-jwt:9.40'
   api 'com.nimbusds:content-type:2.3'
diff --git a/plugins/repository-azure/licenses/msal4j-1.16.0.jar.sha1 b/plugins/repository-azure/licenses/msal4j-1.16.0.jar.sha1
deleted file mode 100644
index 29fe5022a1570..0000000000000
--- a/plugins/repository-azure/licenses/msal4j-1.16.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-708a0a986ed091054f1c08866712e5b41aec6700
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/msal4j-1.16.1.jar.sha1 b/plugins/repository-azure/licenses/msal4j-1.16.1.jar.sha1
new file mode 100644
index 0000000000000..7d24922196be4
--- /dev/null
+++ b/plugins/repository-azure/licenses/msal4j-1.16.1.jar.sha1
@@ -0,0 +1 @@
+4ad89b4632ef9abab883114e77c079843a206862
\ No newline at end of file
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/index/110_constant_keyword.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/index/110_constant_keyword.yml
new file mode 100644
index 0000000000000..9864bfbbb26e9
--- /dev/null
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/index/110_constant_keyword.yml
@@ -0,0 +1,70 @@
+---
+# The test setup includes:
+# - Create index with constant_keyword field type
+# - Check mapping
+# - Index two example documents
+# - Search
+# - Delete Index when connection is teardown
+
+"Mappings and Supported queries":
+  - skip:
+      version: " - 2.99.99"
+      reason: "fixed in 3.0.0"
+
+  # Create index with constant_keyword field type
+  - do:
+      indices.create:
+        index: test
+        body:
+          mappings:
+            properties:
+              genre:
+                type: "constant_keyword"
+                value: "1"
+
+  # Index document
+  - do:
+      index:
+        index: test
+        id: 1
+        body: {
+          "genre": "1"
+        }
+
+  - do:
+      index:
+        index: test
+        id: 2
+        body: {
+          "genre": 1
+        }
+
+  - do:
+      indices.refresh:
+        index: test
+
+  # Check mapping
+  - do:
+      indices.get_mapping:
+        index: test
+  - is_true: test.mappings
+  - match: { test.mappings.properties.genre.type: constant_keyword }
+  - length: { test.mappings.properties.genre: 2 }
+
+  # Verify Document Count
+  - do:
+      search:
+        body: {
+          query: {
+            match_all: {}
+          }
+        }
+
+  - length: { hits.hits: 2 }
+  - match: { hits.hits.0._source.genre: "1" }
+  - match: { hits.hits.1._source.genre: 1 }
+
+  # Delete Index when connection is teardown
+  - do:
+      indices.delete:
+        index: test
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/indices.put_alias/10_basic.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/indices.put_alias/10_basic.yml
index e78a5cf93c666..41f87c1df28ed 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/indices.put_alias/10_basic.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/indices.put_alias/10_basic.yml
@@ -273,8 +273,8 @@
 ---
 "Can set is_hidden":
   - skip:
-      version: " - 2.99.99"
-      reason: "Fix was introduced in 3.0.0"
+      version: " - 2.15.99"
+      reason: "Fix was introduced in 2.16.0"
   - do:
       indices.create:
         index: test_index
@@ -295,8 +295,8 @@
 ---
 "Throws exception with invalid parameters":
   - skip:
-      version: " - 2.99.99"
-      reason: "Fix was introduced in 3.0.0"
+      version: " - 2.15.99"
+      reason: "Fix was introduced in 2.16.0"
 
   - do:
       indices.create:
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/IndicesRequestIT.java b/server/src/internalClusterTest/java/org/opensearch/action/IndicesRequestIT.java
index 84d833569edcb..927a79d4884ef 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/IndicesRequestIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/IndicesRequestIT.java
@@ -84,6 +84,8 @@
 import org.opensearch.action.search.SearchResponse;
 import org.opensearch.action.search.SearchTransportService;
 import org.opensearch.action.search.SearchType;
+import org.opensearch.action.support.clustermanager.term.GetTermVersionAction;
+import org.opensearch.action.support.clustermanager.term.GetTermVersionRequest;
 import org.opensearch.action.support.replication.TransportReplicationActionTests;
 import org.opensearch.action.termvectors.MultiTermVectorsAction;
 import org.opensearch.action.termvectors.MultiTermVectorsRequest;
@@ -195,6 +197,7 @@ public void cleanUp() {
     }
 
     public void testGetFieldMappings() {
+
         String getFieldMappingsShardAction = GetFieldMappingsAction.NAME + "[index][s]";
         interceptTransportActions(getFieldMappingsShardAction);
 
@@ -545,13 +548,14 @@ public void testDeleteIndex() {
     }
 
     public void testGetMappings() {
-        interceptTransportActions(GetMappingsAction.NAME);
-
+        interceptTransportActions(GetTermVersionAction.NAME, GetMappingsAction.NAME);
         GetMappingsRequest getMappingsRequest = new GetMappingsRequest().indices(randomIndicesOrAliases());
         internalCluster().coordOnlyNodeClient().admin().indices().getMappings(getMappingsRequest).actionGet();
 
         clearInterceptedActions();
-        assertSameIndices(getMappingsRequest, GetMappingsAction.NAME);
+
+        assertActionInvocation(GetTermVersionAction.NAME, GetTermVersionRequest.class);
+        assertNoActionInvocation(GetMappingsAction.NAME);
     }
 
     public void testPutMapping() {
@@ -565,8 +569,8 @@ public void testPutMapping() {
     }
 
     public void testGetSettings() {
-        interceptTransportActions(GetSettingsAction.NAME);
 
+        interceptTransportActions(GetSettingsAction.NAME);
         GetSettingsRequest getSettingsRequest = new GetSettingsRequest().indices(randomIndicesOrAliases());
         internalCluster().coordOnlyNodeClient().admin().indices().getSettings(getSettingsRequest).actionGet();
 
@@ -662,6 +666,21 @@ private static void assertSameIndices(IndicesRequest originalRequest, boolean op
         }
     }
 
+    private static void assertActionInvocation(String action, Class<? extends TransportRequest> requestClass) {
+        List<TransportRequest> requests = consumeTransportRequests(action);
+        assertFalse(requests.isEmpty());
+        for (TransportRequest internalRequest : requests) {
+            assertTrue(internalRequest.getClass() == requestClass);
+        }
+    }
+
+    private static void assertNoActionInvocation(String... actions) {
+        for (String action : actions) {
+            List<TransportRequest> requests = consumeTransportRequests(action);
+            assertTrue(requests.isEmpty());
+        }
+    }
+
     private static void assertIndicesSubset(List<String> indices, String... actions) {
         // indices returned by each bulk shard request need to be a subset of the original indices
         for (String action : actions) {
@@ -781,7 +800,6 @@ public List<TransportInterceptor> getTransportInterceptors(
         }
 
         private final Set<String> actions = new HashSet<>();
-
         private final Map<String, List<TransportRequest>> requests = new HashMap<>();
 
         @Override
@@ -831,6 +849,7 @@ public void messageReceived(T request, TransportChannel channel, Task task) thro
                     }
                 }
                 requestHandler.messageReceived(request, channel, task);
+
             }
         }
     }
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIT.java b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIT.java
index 085a32593063a..f23cdbb50b37a 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIT.java
@@ -88,7 +88,11 @@ public void testNodeCounts() {
         Map<String, Integer> expectedCounts = getExpectedCounts(1, 1, 1, 1, 1, 0, 0);
         int numNodes = randomIntBetween(1, 5);
 
-        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse response = client().admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertCounts(response.getNodesStats().getCounts(), total, expectedCounts);
 
         for (int i = 0; i < numNodes; i++) {
@@ -153,7 +157,11 @@ public void testNodeCountsWithDeprecatedMasterRole() throws ExecutionException,
         Map<String, Integer> expectedCounts = getExpectedCounts(0, 1, 1, 0, 0, 0, 0);
 
         Client client = client();
-        ClusterStatsResponse response = client.admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse response = client.admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertCounts(response.getNodesStats().getCounts(), total, expectedCounts);
 
         Set<String> expectedRoles = Set.of(DiscoveryNodeRole.MASTER_ROLE.roleName());
@@ -176,15 +184,60 @@ private void assertShardStats(ClusterStatsIndices.ShardStats stats, int indices,
         assertThat(stats.getReplication(), Matchers.equalTo(replicationFactor));
     }
 
-    public void testIndicesShardStats() throws ExecutionException, InterruptedException {
+    public void testIndicesShardStatsWithoutNodeLevelAggregations() {
+        internalCluster().startNode();
+        ensureGreen();
+        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(false).get();
+        assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.GREEN));
+
+        prepareCreate("test1").setSettings(Settings.builder().put("number_of_shards", 2).put("number_of_replicas", 1)).get();
+
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(false).get();
+        assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.YELLOW));
+        assertThat(response.indicesStats.getDocs().getCount(), Matchers.equalTo(0L));
+        assertThat(response.indicesStats.getIndexCount(), Matchers.equalTo(1));
+        assertShardStats(response.getIndicesStats().getShards(), 1, 2, 2, 0.0);
+
+        // add another node, replicas should get assigned
+        internalCluster().startNode();
+        ensureGreen();
+        index("test1", "type", "1", "f", "f");
+        refresh(); // make the doc visible
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(false).get();
+        assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.GREEN));
+        assertThat(response.indicesStats.getDocs().getCount(), Matchers.equalTo(1L));
+        assertShardStats(response.getIndicesStats().getShards(), 1, 4, 2, 1.0);
+
+        prepareCreate("test2").setSettings(Settings.builder().put("number_of_shards", 3).put("number_of_replicas", 0)).get();
+        ensureGreen();
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(false).get();
+        assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.GREEN));
+        assertThat(response.indicesStats.getIndexCount(), Matchers.equalTo(2));
+        assertShardStats(response.getIndicesStats().getShards(), 2, 7, 5, 2.0 / 5);
+
+        assertThat(response.getIndicesStats().getShards().getAvgIndexPrimaryShards(), Matchers.equalTo(2.5));
+        assertThat(response.getIndicesStats().getShards().getMinIndexPrimaryShards(), Matchers.equalTo(2));
+        assertThat(response.getIndicesStats().getShards().getMaxIndexPrimaryShards(), Matchers.equalTo(3));
+
+        assertThat(response.getIndicesStats().getShards().getAvgIndexShards(), Matchers.equalTo(3.5));
+        assertThat(response.getIndicesStats().getShards().getMinIndexShards(), Matchers.equalTo(3));
+        assertThat(response.getIndicesStats().getShards().getMaxIndexShards(), Matchers.equalTo(4));
+
+        assertThat(response.getIndicesStats().getShards().getAvgIndexReplication(), Matchers.equalTo(0.5));
+        assertThat(response.getIndicesStats().getShards().getMinIndexReplication(), Matchers.equalTo(0.0));
+        assertThat(response.getIndicesStats().getShards().getMaxIndexReplication(), Matchers.equalTo(1.0));
+
+    }
+
+    public void testIndicesShardStatsWithNodeLevelAggregations() {
         internalCluster().startNode();
         ensureGreen();
-        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(true).get();
         assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.GREEN));
 
         prepareCreate("test1").setSettings(Settings.builder().put("number_of_shards", 2).put("number_of_replicas", 1)).get();
 
-        response = client().admin().cluster().prepareClusterStats().get();
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(true).get();
         assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.YELLOW));
         assertThat(response.indicesStats.getDocs().getCount(), Matchers.equalTo(0L));
         assertThat(response.indicesStats.getIndexCount(), Matchers.equalTo(1));
@@ -195,14 +248,14 @@ public void testIndicesShardStats() throws ExecutionException, InterruptedExcept
         ensureGreen();
         index("test1", "type", "1", "f", "f");
         refresh(); // make the doc visible
-        response = client().admin().cluster().prepareClusterStats().get();
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(true).get();
         assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.GREEN));
         assertThat(response.indicesStats.getDocs().getCount(), Matchers.equalTo(1L));
         assertShardStats(response.getIndicesStats().getShards(), 1, 4, 2, 1.0);
 
         prepareCreate("test2").setSettings(Settings.builder().put("number_of_shards", 3).put("number_of_replicas", 0)).get();
         ensureGreen();
-        response = client().admin().cluster().prepareClusterStats().get();
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(true).get();
         assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.GREEN));
         assertThat(response.indicesStats.getIndexCount(), Matchers.equalTo(2));
         assertShardStats(response.getIndicesStats().getShards(), 2, 7, 5, 2.0 / 5);
@@ -225,7 +278,11 @@ public void testValuesSmokeScreen() throws IOException, ExecutionException, Inte
         internalCluster().startNodes(randomIntBetween(1, 3));
         index("test1", "type", "1", "f", "f");
 
-        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse response = client().admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         String msg = response.toString();
         assertThat(msg, response.getTimestamp(), Matchers.greaterThan(946681200000L)); // 1 Jan 2000
         assertThat(msg, response.indicesStats.getStore().getSizeInBytes(), Matchers.greaterThan(0L));
@@ -265,13 +322,21 @@ public void testAllocatedProcessors() throws Exception {
         internalCluster().startNode(Settings.builder().put(OpenSearchExecutors.NODE_PROCESSORS_SETTING.getKey(), 7).build());
         waitForNodes(1);
 
-        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse response = client().admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertThat(response.getNodesStats().getOs().getAllocatedProcessors(), equalTo(7));
     }
 
     public void testClusterStatusWhenStateNotRecovered() throws Exception {
         internalCluster().startClusterManagerOnlyNode(Settings.builder().put("gateway.recover_after_nodes", 2).build());
-        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse response = client().admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertThat(response.getStatus(), equalTo(ClusterHealthStatus.RED));
 
         if (randomBoolean()) {
@@ -281,14 +346,18 @@ public void testClusterStatusWhenStateNotRecovered() throws Exception {
         }
         // wait for the cluster status to settle
         ensureGreen();
-        response = client().admin().cluster().prepareClusterStats().get();
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(randomBoolean()).get();
         assertThat(response.getStatus(), equalTo(ClusterHealthStatus.GREEN));
     }
 
     public void testFieldTypes() {
         internalCluster().startNode();
         ensureGreen();
-        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse response = client().admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.GREEN));
         assertTrue(response.getIndicesStats().getMappings().getFieldTypeStats().isEmpty());
 
@@ -301,7 +370,7 @@ public void testFieldTypes() {
                     + "\"eggplant\":{\"type\":\"integer\"}}}}}"
             )
             .get();
-        response = client().admin().cluster().prepareClusterStats().get();
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(randomBoolean()).get();
         assertThat(response.getIndicesStats().getMappings().getFieldTypeStats().size(), equalTo(3));
         Set<IndexFeatureStats> stats = response.getIndicesStats().getMappings().getFieldTypeStats();
         for (IndexFeatureStats stat : stats) {
@@ -329,7 +398,11 @@ public void testNodeRolesWithMasterLegacySettings() throws ExecutionException, I
         Map<String, Integer> expectedCounts = getExpectedCounts(0, 1, 1, 0, 1, 0, 0);
 
         Client client = client();
-        ClusterStatsResponse clusterStatsResponse = client.admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse clusterStatsResponse = client.admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertCounts(clusterStatsResponse.getNodesStats().getCounts(), total, expectedCounts);
 
         Set<String> expectedRoles = Set.of(
@@ -359,7 +432,11 @@ public void testNodeRolesWithClusterManagerRole() throws ExecutionException, Int
         Map<String, Integer> expectedCounts = getExpectedCounts(0, 1, 1, 0, 1, 0, 0);
 
         Client client = client();
-        ClusterStatsResponse clusterStatsResponse = client.admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse clusterStatsResponse = client.admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertCounts(clusterStatsResponse.getNodesStats().getCounts(), total, expectedCounts);
 
         Set<String> expectedRoles = Set.of(
@@ -383,7 +460,11 @@ public void testNodeRolesWithSeedDataNodeLegacySettings() throws ExecutionExcept
         Map<String, Integer> expectedRoleCounts = getExpectedCounts(1, 1, 1, 0, 1, 0, 0);
 
         Client client = client();
-        ClusterStatsResponse clusterStatsResponse = client.admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse clusterStatsResponse = client.admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertCounts(clusterStatsResponse.getNodesStats().getCounts(), total, expectedRoleCounts);
 
         Set<String> expectedRoles = Set.of(
@@ -410,7 +491,11 @@ public void testNodeRolesWithDataNodeLegacySettings() throws ExecutionException,
         Map<String, Integer> expectedRoleCounts = getExpectedCounts(1, 1, 1, 0, 1, 0, 0);
 
         Client client = client();
-        ClusterStatsResponse clusterStatsResponse = client.admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse clusterStatsResponse = client.admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertCounts(clusterStatsResponse.getNodesStats().getCounts(), total, expectedRoleCounts);
 
         Set<Set<String>> expectedNodesRoles = Set.of(
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/CreateIndexIT.java b/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/CreateIndexIT.java
index 1c182b05fa4a8..fbe713d9e22c4 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/CreateIndexIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/CreateIndexIT.java
@@ -406,4 +406,28 @@ public void testIndexNameInResponse() {
         assertEquals("Should have index name in response", "foo", response.index());
     }
 
+    public void testCreateIndexWithNullReplicaCountPickUpClusterReplica() {
+        int numReplicas = 3;
+        String indexName = "test-idx-1";
+        assertAcked(
+            client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setPersistentSettings(Settings.builder().put("cluster.default_number_of_replicas", numReplicas).build())
+                .get()
+        );
+        Settings settings = Settings.builder()
+            .put(IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING.getKey(), 1)
+            .put(IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING.getKey(), (String) null)
+            .build();
+        assertAcked(client().admin().indices().prepareCreate(indexName).setSettings(settings).get());
+        IndicesService indicesService = internalCluster().getInstance(IndicesService.class, internalCluster().getClusterManagerName());
+        for (IndexService indexService : indicesService) {
+            assertEquals(indexName, indexService.index().getName());
+            assertEquals(
+                numReplicas,
+                (int) indexService.getIndexSettings().getSettings().getAsInt(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, null)
+            );
+        }
+    }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerIT.java b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerIT.java
index 5074971ab1a1f..7d2e24c777da3 100644
--- a/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerIT.java
@@ -8,9 +8,17 @@
 
 package org.opensearch.gateway.remote;
 
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
 import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsResponse;
+import org.opensearch.cluster.coordination.PersistedStateStats;
+import org.opensearch.cluster.routing.IndexRoutingTable;
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.discovery.DiscoveryStats;
+import org.opensearch.gateway.remote.model.RemoteRoutingTableBlobStore;
+import org.opensearch.index.remote.RemoteStoreEnums;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
 import org.opensearch.remotestore.RemoteStoreBaseIntegTestCase;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
@@ -18,21 +26,29 @@
 import org.junit.Before;
 
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.ArrayList;
 import java.util.Base64;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
 
+import static org.opensearch.common.util.FeatureFlags.REMOTE_PUBLICATION_EXPERIMENTAL;
 import static org.opensearch.gateway.remote.RemoteClusterStateCleanupManager.CLUSTER_STATE_CLEANUP_INTERVAL_DEFAULT;
 import static org.opensearch.gateway.remote.RemoteClusterStateCleanupManager.REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING;
 import static org.opensearch.gateway.remote.RemoteClusterStateCleanupManager.RETAINED_MANIFESTS;
 import static org.opensearch.gateway.remote.RemoteClusterStateCleanupManager.SKIP_CLEANUP_STATE_CHANGES;
 import static org.opensearch.gateway.remote.RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_TABLE;
 import static org.opensearch.indices.IndicesService.CLUSTER_DEFAULT_INDEX_REFRESH_INTERVAL_SETTING;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 
 @OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
 public class RemoteClusterStateCleanupManagerIT extends RemoteStoreBaseIntegTestCase {
 
     private static final String INDEX_NAME = "test-index";
+    private final RemoteStoreEnums.PathType pathType = RemoteStoreEnums.PathType.HASHED_PREFIX;
 
     @Before
     public void setup() {
@@ -52,6 +68,11 @@ private Map<String, Long> initialTestSetup(int shardCount, int replicaCount, int
         return indexStats;
     }
 
+    private void initialTestSetup(int shardCount, int replicaCount, int dataNodeCount, int clusterManagerNodeCount, Settings settings) {
+        prepareCluster(clusterManagerNodeCount, dataNodeCount, INDEX_NAME, replicaCount, shardCount, settings);
+        ensureGreen(INDEX_NAME);
+    }
+
     public void testRemoteCleanupTaskUpdated() {
         int shardCount = randomIntBetween(1, 2);
         int replicaCount = 1;
@@ -144,6 +165,102 @@ public void testRemoteCleanupDeleteStale() throws Exception {
         assertTrue(response.isAcknowledged());
     }
 
+    public void testRemoteCleanupDeleteStaleIndexRoutingFiles() throws Exception {
+        clusterSettingsSuppliedByTest = true;
+        Path segmentRepoPath = randomRepoPath();
+        Path translogRepoPath = randomRepoPath();
+        Path remoteRoutingTableRepoPath = randomRepoPath();
+        Settings.Builder settingsBuilder = Settings.builder();
+        settingsBuilder.put(
+            buildRemoteStoreNodeAttributes(
+                REPOSITORY_NAME,
+                segmentRepoPath,
+                REPOSITORY_2_NAME,
+                translogRepoPath,
+                REMOTE_ROUTING_TABLE_REPO,
+                remoteRoutingTableRepoPath,
+                false
+            )
+        );
+        settingsBuilder.put(
+            RemoteRoutingTableBlobStore.REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING.getKey(),
+            RemoteStoreEnums.PathType.HASHED_PREFIX.toString()
+        )
+            .put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, REMOTE_ROUTING_TABLE_REPO)
+            .put(REMOTE_PUBLICATION_EXPERIMENTAL, true);
+
+        int shardCount = randomIntBetween(1, 2);
+        int replicaCount = 1;
+        int dataNodeCount = shardCount * (replicaCount + 1);
+        int clusterManagerNodeCount = 1;
+        initialTestSetup(shardCount, replicaCount, dataNodeCount, clusterManagerNodeCount, settingsBuilder.build());
+
+        // update cluster state 21 times to ensure that clean up has run after this will upload 42 manifest files
+        // to repository, if manifest files are less than that it means clean up has run
+        updateClusterStateNTimes(RETAINED_MANIFESTS + SKIP_CLEANUP_STATE_CHANGES + 1);
+
+        RepositoriesService repositoriesService = internalCluster().getClusterManagerNodeInstance(RepositoriesService.class);
+        BlobStoreRepository repository = (BlobStoreRepository) repositoriesService.repository(REPOSITORY_NAME);
+        BlobPath baseMetadataPath = getBaseMetadataPath(repository);
+
+        BlobStoreRepository routingTableRepository = (BlobStoreRepository) repositoriesService.repository(REMOTE_ROUTING_TABLE_REPO);
+        List<IndexRoutingTable> indexRoutingTables = new ArrayList<>(getClusterState().routingTable().indicesRouting().values());
+        BlobPath indexRoutingPath = getIndexRoutingPath(baseMetadataPath, indexRoutingTables.get(0).getIndex().getUUID());
+        assertBusy(() -> {
+            // There would be >=3 files as shards will transition from UNASSIGNED -> INIT -> STARTED state
+            assertTrue(routingTableRepository.blobStore().blobContainer(indexRoutingPath).listBlobs().size() >= 3);
+        });
+
+        RemoteClusterStateCleanupManager remoteClusterStateCleanupManager = internalCluster().getClusterManagerNodeInstance(
+            RemoteClusterStateCleanupManager.class
+        );
+
+        // set cleanup interval to 100 ms to make the test faster
+        ClusterUpdateSettingsResponse response = client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setPersistentSettings(Settings.builder().put(REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING.getKey(), "100ms"))
+            .get();
+
+        assertTrue(response.isAcknowledged());
+        assertBusy(() -> assertEquals(100, remoteClusterStateCleanupManager.getStaleFileDeletionTask().getInterval().getMillis()));
+
+        String clusterManagerNode = internalCluster().getClusterManagerName();
+        NodesStatsResponse nodesStatsResponse = client().admin()
+            .cluster()
+            .prepareNodesStats(clusterManagerNode)
+            .addMetric(NodesStatsRequest.Metric.DISCOVERY.metricName())
+            .get();
+        verifyIndexRoutingFilesDeletion(routingTableRepository, indexRoutingPath, nodesStatsResponse);
+
+        // disable the clean up to avoid race condition during shutdown
+        response = client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setPersistentSettings(Settings.builder().put(REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING.getKey(), "-1"))
+            .get();
+        assertTrue(response.isAcknowledged());
+    }
+
+    private void verifyIndexRoutingFilesDeletion(
+        BlobStoreRepository routingTableRepository,
+        BlobPath indexRoutingPath,
+        NodesStatsResponse nodesStatsResponse
+    ) throws Exception {
+        assertBusy(() -> { assertEquals(1, routingTableRepository.blobStore().blobContainer(indexRoutingPath).listBlobs().size()); });
+
+        // Verify index routing files delete stats
+        DiscoveryStats discoveryStats = nodesStatsResponse.getNodes().get(0).getDiscoveryStats();
+        assertNotNull(discoveryStats.getClusterStateStats());
+        for (PersistedStateStats persistedStateStats : discoveryStats.getClusterStateStats().getPersistenceStats()) {
+            Map<String, AtomicLong> extendedFields = persistedStateStats.getExtendedFields();
+            assertTrue(extendedFields.containsKey(RemotePersistenceStats.INDEX_ROUTING_FILES_CLEANUP_ATTEMPT_FAILED_COUNT));
+            long cleanupAttemptFailedCount = extendedFields.get(RemotePersistenceStats.INDEX_ROUTING_FILES_CLEANUP_ATTEMPT_FAILED_COUNT)
+                .get();
+            assertEquals(0, cleanupAttemptFailedCount);
+        }
+    }
+
     private void updateClusterStateNTimes(int n) {
         int newReplicaCount = randomIntBetween(0, 3);
         for (int i = n; i > 0; i--) {
@@ -155,4 +272,22 @@ private void updateClusterStateNTimes(int n) {
             assertTrue(response.isAcknowledged());
         }
     }
+
+    private BlobPath getBaseMetadataPath(BlobStoreRepository repository) {
+        return repository.basePath()
+            .add(
+                Base64.getUrlEncoder()
+                    .withoutPadding()
+                    .encodeToString(getClusterState().getClusterName().value().getBytes(StandardCharsets.UTF_8))
+            )
+            .add("cluster-state")
+            .add(getClusterState().metadata().clusterUUID());
+    }
+
+    private BlobPath getIndexRoutingPath(BlobPath baseMetadataPath, String indexUUID) {
+        return pathType.path(
+            RemoteStorePathStrategy.PathInput.builder().basePath(baseMetadataPath.add(INDEX_ROUTING_TABLE)).indexUUID(indexUUID).build(),
+            RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64
+        );
+    }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteRoutingTableServiceIT.java b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteRoutingTableServiceIT.java
new file mode 100644
index 0000000000000..b0d046cbdf3db
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteRoutingTableServiceIT.java
@@ -0,0 +1,364 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsResponse;
+import org.opensearch.action.admin.cluster.state.ClusterStateRequest;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.gateway.remote.model.RemoteRoutingTableBlobStore;
+import org.opensearch.index.remote.RemoteStoreEnums;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
+import org.opensearch.remotestore.RemoteStoreBaseIntegTestCase;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchIntegTestCase;
+import org.junit.Before;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.opensearch.common.util.FeatureFlags.REMOTE_PUBLICATION_EXPERIMENTAL;
+import static org.opensearch.gateway.remote.RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_TABLE;
+import static org.opensearch.indices.IndicesService.CLUSTER_DEFAULT_INDEX_REFRESH_INTERVAL_SETTING;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
+
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
+public class RemoteRoutingTableServiceIT extends RemoteStoreBaseIntegTestCase {
+    private static final String INDEX_NAME = "test-index";
+    private static final String INDEX_NAME_1 = "test-index-1";
+    BlobPath indexRoutingPath;
+    AtomicInteger indexRoutingFiles = new AtomicInteger();
+    private final RemoteStoreEnums.PathType pathType = RemoteStoreEnums.PathType.HASHED_PREFIX;
+
+    @Before
+    public void setup() {
+        asyncUploadMockFsRepo = false;
+    }
+
+    @Override
+    protected Settings nodeSettings(int nodeOrdinal) {
+        return Settings.builder()
+            .put(super.nodeSettings(nodeOrdinal))
+            .put(REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), true)
+            .put(
+                RemoteRoutingTableBlobStore.REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING.getKey(),
+                RemoteStoreEnums.PathType.HASHED_PREFIX.toString()
+            )
+            .put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, REMOTE_ROUTING_TABLE_REPO)
+            .put(REMOTE_PUBLICATION_EXPERIMENTAL, true)
+            .build();
+    }
+
+    public void testRemoteRoutingTableIndexLifecycle() throws Exception {
+        BlobStoreRepository repository = prepareClusterAndVerifyRepository();
+
+        RemoteClusterStateService remoteClusterStateService = internalCluster().getClusterManagerNodeInstance(
+            RemoteClusterStateService.class
+        );
+        RemoteManifestManager remoteManifestManager = remoteClusterStateService.getRemoteManifestManager();
+        Optional<ClusterMetadataManifest> latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+        List<String> expectedIndexNames = new ArrayList<>();
+        List<String> deletedIndexNames = new ArrayList<>();
+        verifyUpdatesInManifestFile(latestManifest, expectedIndexNames, 1, deletedIndexNames, true);
+
+        List<RoutingTable> routingTableVersions = getRoutingTableFromAllNodes();
+        assertTrue(areRoutingTablesSame(routingTableVersions));
+
+        // Update index settings
+        updateIndexSettings(INDEX_NAME, IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 2);
+        ensureGreen(INDEX_NAME);
+        assertBusy(() -> {
+            int indexRoutingFilesAfterUpdate = repository.blobStore().blobContainer(indexRoutingPath).listBlobs().size();
+            // At-least 3 new index routing files will be created as shards will transition from INIT -> UNASSIGNED -> STARTED state
+            assertTrue(indexRoutingFilesAfterUpdate >= indexRoutingFiles.get() + 3);
+        });
+
+        latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+        verifyUpdatesInManifestFile(latestManifest, expectedIndexNames, 1, deletedIndexNames, true);
+
+        routingTableVersions = getRoutingTableFromAllNodes();
+        assertTrue(areRoutingTablesSame(routingTableVersions));
+
+        // Delete the index and assert its deletion
+        deleteIndexAndVerify(remoteManifestManager);
+
+        routingTableVersions = getRoutingTableFromAllNodes();
+        assertTrue(areRoutingTablesSame(routingTableVersions));
+    }
+
+    public void testRemoteRoutingTableEmptyRoutingTableDiff() throws Exception {
+        prepareClusterAndVerifyRepository();
+
+        RemoteClusterStateService remoteClusterStateService = internalCluster().getClusterManagerNodeInstance(
+            RemoteClusterStateService.class
+        );
+        RemoteManifestManager remoteManifestManager = remoteClusterStateService.getRemoteManifestManager();
+        Optional<ClusterMetadataManifest> latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+        List<String> expectedIndexNames = new ArrayList<>();
+        List<String> deletedIndexNames = new ArrayList<>();
+        verifyUpdatesInManifestFile(latestManifest, expectedIndexNames, 1, deletedIndexNames, true);
+
+        List<RoutingTable> routingTableVersions = getRoutingTableFromAllNodes();
+        assertTrue(areRoutingTablesSame(routingTableVersions));
+
+        // Update cluster settings
+        ClusterUpdateSettingsResponse response = client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setPersistentSettings(Settings.builder().put(CLUSTER_DEFAULT_INDEX_REFRESH_INTERVAL_SETTING.getKey(), 0, TimeUnit.SECONDS))
+            .get();
+        assertTrue(response.isAcknowledged());
+
+        latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+        verifyUpdatesInManifestFile(latestManifest, expectedIndexNames, 1, deletedIndexNames, false);
+
+        routingTableVersions = getRoutingTableFromAllNodes();
+        assertTrue(areRoutingTablesSame(routingTableVersions));
+    }
+
+    public void testRemoteRoutingTableIndexNodeRestart() throws Exception {
+        BlobStoreRepository repository = prepareClusterAndVerifyRepository();
+
+        List<RoutingTable> routingTableVersions = getRoutingTableFromAllNodes();
+        assertTrue(areRoutingTablesSame(routingTableVersions));
+
+        // Ensure node comes healthy after restart
+        Set<String> dataNodes = internalCluster().getDataNodeNames();
+        internalCluster().restartNode(randomFrom(dataNodes));
+        ensureGreen();
+        ensureGreen(INDEX_NAME);
+
+        // ensure restarted node joins and the cluster is stable
+        assertEquals(3, internalCluster().clusterService().state().nodes().getDataNodes().size());
+        ensureStableCluster(4);
+        assertRemoteStoreRepositoryOnAllNodes(REMOTE_ROUTING_TABLE_REPO);
+
+        assertBusy(() -> {
+            int indexRoutingFilesAfterNodeDrop = repository.blobStore().blobContainer(indexRoutingPath).listBlobs().size();
+            assertTrue(indexRoutingFilesAfterNodeDrop > indexRoutingFiles.get());
+        });
+
+        RemoteClusterStateService remoteClusterStateService = internalCluster().getClusterManagerNodeInstance(
+            RemoteClusterStateService.class
+        );
+        RemoteManifestManager remoteManifestManager = remoteClusterStateService.getRemoteManifestManager();
+        Optional<ClusterMetadataManifest> latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+        List<String> expectedIndexNames = new ArrayList<>();
+        List<String> deletedIndexNames = new ArrayList<>();
+        verifyUpdatesInManifestFile(latestManifest, expectedIndexNames, 1, deletedIndexNames, true);
+    }
+
+    public void testRemoteRoutingTableIndexMasterRestart() throws Exception {
+        BlobStoreRepository repository = prepareClusterAndVerifyRepository();
+
+        List<RoutingTable> routingTableVersions = getRoutingTableFromAllNodes();
+        assertTrue(areRoutingTablesSame(routingTableVersions));
+
+        // Ensure node comes healthy after restart
+        String clusterManagerName = internalCluster().getClusterManagerName();
+        internalCluster().restartNode(clusterManagerName);
+        ensureGreen();
+        ensureGreen(INDEX_NAME);
+
+        // ensure master is elected and the cluster is stable
+        assertNotNull(internalCluster().clusterService().state().nodes().getClusterManagerNode());
+        ensureStableCluster(4);
+        assertRemoteStoreRepositoryOnAllNodes(REMOTE_ROUTING_TABLE_REPO);
+
+        assertBusy(() -> {
+            int indexRoutingFilesAfterNodeDrop = repository.blobStore().blobContainer(indexRoutingPath).listBlobs().size();
+            assertTrue(indexRoutingFilesAfterNodeDrop > indexRoutingFiles.get());
+        });
+
+        RemoteClusterStateService remoteClusterStateService = internalCluster().getClusterManagerNodeInstance(
+            RemoteClusterStateService.class
+        );
+        RemoteManifestManager remoteManifestManager = remoteClusterStateService.getRemoteManifestManager();
+        Optional<ClusterMetadataManifest> latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+        List<String> expectedIndexNames = new ArrayList<>();
+        List<String> deletedIndexNames = new ArrayList<>();
+        verifyUpdatesInManifestFile(latestManifest, expectedIndexNames, 1, deletedIndexNames, true);
+    }
+
+    private BlobStoreRepository prepareClusterAndVerifyRepository() throws Exception {
+        clusterSettingsSuppliedByTest = true;
+        Path segmentRepoPath = randomRepoPath();
+        Path translogRepoPath = randomRepoPath();
+        Path remoteRoutingTableRepoPath = randomRepoPath();
+        Settings settings = buildRemoteStoreNodeAttributes(
+            REPOSITORY_NAME,
+            segmentRepoPath,
+            REPOSITORY_2_NAME,
+            translogRepoPath,
+            REMOTE_ROUTING_TABLE_REPO,
+            remoteRoutingTableRepoPath,
+            false
+        );
+        prepareCluster(1, 3, INDEX_NAME, 1, 5, settings);
+        ensureGreen(INDEX_NAME);
+
+        RepositoriesService repositoriesService = internalCluster().getClusterManagerNodeInstance(RepositoriesService.class);
+        BlobStoreRepository repository = (BlobStoreRepository) repositoriesService.repository(REMOTE_ROUTING_TABLE_REPO);
+
+        BlobPath baseMetadataPath = getBaseMetadataPath(repository);
+        List<IndexRoutingTable> indexRoutingTables = new ArrayList<>(getClusterState().routingTable().indicesRouting().values());
+        indexRoutingPath = getIndexRoutingPath(baseMetadataPath.add(INDEX_ROUTING_TABLE), indexRoutingTables.get(0).getIndex().getUUID());
+
+        assertBusy(() -> {
+            indexRoutingFiles.set(repository.blobStore().blobContainer(indexRoutingPath).listBlobs().size());
+            // There would be >=3 files as shards will transition from UNASSIGNED -> INIT -> STARTED state
+            assertTrue(indexRoutingFiles.get() >= 3);
+        });
+        assertRemoteStoreRepositoryOnAllNodes(REMOTE_ROUTING_TABLE_REPO);
+        return repository;
+    }
+
+    private BlobPath getBaseMetadataPath(BlobStoreRepository repository) {
+        return repository.basePath()
+            .add(
+                Base64.getUrlEncoder()
+                    .withoutPadding()
+                    .encodeToString(getClusterState().getClusterName().value().getBytes(StandardCharsets.UTF_8))
+            )
+            .add("cluster-state")
+            .add(getClusterState().metadata().clusterUUID());
+    }
+
+    private BlobPath getIndexRoutingPath(BlobPath indexRoutingPath, String indexUUID) {
+        RemoteStoreEnums.PathHashAlgorithm pathHashAlgo = RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64;
+        return pathType.path(
+            RemoteStorePathStrategy.PathInput.builder().basePath(indexRoutingPath).indexUUID(indexUUID).build(),
+            pathHashAlgo
+        );
+    }
+
+    private void verifyUpdatesInManifestFile(
+        Optional<ClusterMetadataManifest> latestManifest,
+        List<String> expectedIndexNames,
+        int expectedIndicesRoutingFilesInManifest,
+        List<String> expectedDeletedIndex,
+        boolean isRoutingTableDiffFileExpected
+    ) {
+        assertTrue(latestManifest.isPresent());
+        ClusterMetadataManifest manifest = latestManifest.get();
+
+        assertEquals(expectedIndexNames, manifest.getDiffManifest().getIndicesRoutingUpdated());
+        assertEquals(expectedDeletedIndex, manifest.getDiffManifest().getIndicesDeleted());
+        assertEquals(expectedIndicesRoutingFilesInManifest, manifest.getIndicesRouting().size());
+        for (ClusterMetadataManifest.UploadedIndexMetadata uploadedFilename : manifest.getIndicesRouting()) {
+            assertTrue(uploadedFilename.getUploadedFilename().contains(indexRoutingPath.buildAsString()));
+        }
+        assertEquals(isRoutingTableDiffFileExpected, manifest.getDiffManifest().getIndicesRoutingDiffPath() != null);
+    }
+
+    private List<RoutingTable> getRoutingTableFromAllNodes() throws ExecutionException, InterruptedException {
+        String[] allNodes = internalCluster().getNodeNames();
+        List<RoutingTable> routingTables = new ArrayList<>();
+        for (String node : allNodes) {
+            RoutingTable routingTable = internalCluster().client(node)
+                .admin()
+                .cluster()
+                .state(new ClusterStateRequest().local(true))
+                .get()
+                .getState()
+                .routingTable();
+            routingTables.add(routingTable);
+        }
+        return routingTables;
+    }
+
+    private boolean areRoutingTablesSame(List<RoutingTable> routingTables) {
+        if (routingTables == null || routingTables.isEmpty()) {
+            return false;
+        }
+
+        RoutingTable firstRoutingTable = routingTables.get(0);
+        for (RoutingTable routingTable : routingTables) {
+            if (!compareRoutingTables(firstRoutingTable, routingTable)) {
+                logger.info("Responses are not the same: {} {}", firstRoutingTable, routingTable);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean compareRoutingTables(RoutingTable a, RoutingTable b) {
+        if (a == b) return true;
+        if (b == null || a.getClass() != b.getClass()) return false;
+        if (a.version() != b.version()) return false;
+        if (a.indicesRouting().size() != b.indicesRouting().size()) return false;
+
+        for (Map.Entry<String, IndexRoutingTable> entry : a.indicesRouting().entrySet()) {
+            IndexRoutingTable thisIndexRoutingTable = entry.getValue();
+            IndexRoutingTable thatIndexRoutingTable = b.indicesRouting().get(entry.getKey());
+            if (!thatIndexRoutingTable.equals(thatIndexRoutingTable)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private void updateIndexSettings(String indexName, String settingKey, int settingValue) {
+        client().admin()
+            .indices()
+            .prepareUpdateSettings(indexName)
+            .setSettings(Settings.builder().put(settingKey, settingValue))
+            .execute()
+            .actionGet();
+    }
+
+    private void deleteIndexAndVerify(RemoteManifestManager remoteManifestManager) {
+        client().admin().indices().prepareDelete(INDEX_NAME).execute().actionGet();
+        assertFalse(client().admin().indices().prepareExists(INDEX_NAME).get().isExists());
+
+        // Verify index is marked deleted in manifest
+        Optional<ClusterMetadataManifest> latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+        assertTrue(latestManifest.isPresent());
+        ClusterMetadataManifest manifest = latestManifest.get();
+        assertTrue(manifest.getDiffManifest().getIndicesRoutingUpdated().isEmpty());
+        assertTrue(manifest.getDiffManifest().getIndicesDeleted().contains(INDEX_NAME));
+        assertTrue(manifest.getIndicesRouting().isEmpty());
+    }
+
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/ingest/IngestClientIT.java b/server/src/internalClusterTest/java/org/opensearch/ingest/IngestClientIT.java
index 657d0f178e096..0eb37a7b25618 100644
--- a/server/src/internalClusterTest/java/org/opensearch/ingest/IngestClientIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/ingest/IngestClientIT.java
@@ -315,6 +315,87 @@ public void testBulkWithUpsert() throws Exception {
         assertThat(upserted.get("processed"), equalTo(true));
     }
 
+    public void testSingleDocIngestFailure() throws Exception {
+        createIndex("test");
+        BytesReference source = BytesReference.bytes(
+            jsonBuilder().startObject()
+                .field("description", "my_pipeline")
+                .startArray("processors")
+                .startObject()
+                .startObject("test")
+                .endObject()
+                .endObject()
+                .endArray()
+                .endObject()
+        );
+        PutPipelineRequest putPipelineRequest = new PutPipelineRequest("_id", source, MediaTypeRegistry.JSON);
+        client().admin().cluster().putPipeline(putPipelineRequest).get();
+
+        GetPipelineRequest getPipelineRequest = new GetPipelineRequest("_id");
+        GetPipelineResponse getResponse = client().admin().cluster().getPipeline(getPipelineRequest).get();
+        assertThat(getResponse.isFound(), is(true));
+        assertThat(getResponse.pipelines().size(), equalTo(1));
+        assertThat(getResponse.pipelines().get(0).getId(), equalTo("_id"));
+
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> client().prepareIndex("test")
+                .setId("1")
+                .setPipeline("_id")
+                .setSource(Requests.INDEX_CONTENT_TYPE, "field", "value", "fail", true)
+                .get()
+        );
+
+        DeletePipelineRequest deletePipelineRequest = new DeletePipelineRequest("_id");
+        AcknowledgedResponse response = client().admin().cluster().deletePipeline(deletePipelineRequest).get();
+        assertThat(response.isAcknowledged(), is(true));
+
+        getResponse = client().admin().cluster().prepareGetPipeline("_id").get();
+        assertThat(getResponse.isFound(), is(false));
+        assertThat(getResponse.pipelines().size(), equalTo(0));
+    }
+
+    public void testSingleDocIngestDrop() throws Exception {
+        createIndex("test");
+        BytesReference source = BytesReference.bytes(
+            jsonBuilder().startObject()
+                .field("description", "my_pipeline")
+                .startArray("processors")
+                .startObject()
+                .startObject("test")
+                .endObject()
+                .endObject()
+                .endArray()
+                .endObject()
+        );
+        PutPipelineRequest putPipelineRequest = new PutPipelineRequest("_id", source, MediaTypeRegistry.JSON);
+        client().admin().cluster().putPipeline(putPipelineRequest).get();
+
+        GetPipelineRequest getPipelineRequest = new GetPipelineRequest("_id");
+        GetPipelineResponse getResponse = client().admin().cluster().getPipeline(getPipelineRequest).get();
+        assertThat(getResponse.isFound(), is(true));
+        assertThat(getResponse.pipelines().size(), equalTo(1));
+        assertThat(getResponse.pipelines().get(0).getId(), equalTo("_id"));
+
+        DocWriteResponse indexResponse = client().prepareIndex("test")
+            .setId("1")
+            .setPipeline("_id")
+            .setSource(Requests.INDEX_CONTENT_TYPE, "field", "value", "drop", true)
+            .get();
+        assertEquals(DocWriteResponse.Result.NOOP, indexResponse.getResult());
+
+        Map<String, Object> doc = client().prepareGet("test", "1").get().getSourceAsMap();
+        assertNull(doc);
+
+        DeletePipelineRequest deletePipelineRequest = new DeletePipelineRequest("_id");
+        AcknowledgedResponse response = client().admin().cluster().deletePipeline(deletePipelineRequest).get();
+        assertThat(response.isAcknowledged(), is(true));
+
+        getResponse = client().admin().cluster().prepareGetPipeline("_id").get();
+        assertThat(getResponse.isFound(), is(false));
+        assertThat(getResponse.pipelines().size(), equalTo(0));
+    }
+
     public void test() throws Exception {
         BytesReference source = BytesReference.bytes(
             jsonBuilder().startObject()
diff --git a/server/src/internalClusterTest/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionForClusterManagerIT.java b/server/src/internalClusterTest/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionForClusterManagerIT.java
index b9da5ffb86af0..e3a4216e772fb 100644
--- a/server/src/internalClusterTest/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionForClusterManagerIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionForClusterManagerIT.java
@@ -12,7 +12,11 @@
 import org.apache.logging.log4j.Logger;
 import org.opensearch.action.admin.indices.alias.get.GetAliasesRequest;
 import org.opensearch.action.admin.indices.alias.get.GetAliasesResponse;
+import org.opensearch.action.support.clustermanager.term.GetTermVersionAction;
+import org.opensearch.action.support.clustermanager.term.GetTermVersionResponse;
 import org.opensearch.client.node.NodeClient;
+import org.opensearch.cluster.coordination.ClusterStateTermVersion;
+import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
@@ -20,6 +24,7 @@
 import org.opensearch.node.IoUsageStats;
 import org.opensearch.node.ResourceUsageCollectorService;
 import org.opensearch.node.resource.tracker.ResourceTrackerSettings;
+import org.opensearch.plugins.Plugin;
 import org.opensearch.ratelimitting.admissioncontrol.controllers.CpuBasedAdmissionController;
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlActionType;
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlMode;
@@ -29,9 +34,13 @@
 import org.opensearch.rest.action.admin.indices.RestGetAliasesAction;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.rest.FakeRestRequest;
+import org.opensearch.test.transport.MockTransportService;
+import org.opensearch.transport.TransportService;
 import org.junit.Before;
 
+import java.util.Collection;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicReference;
@@ -62,6 +71,10 @@ public class AdmissionForClusterManagerIT extends OpenSearchIntegTestCase {
         .put(CLUSTER_ADMIN_CPU_USAGE_LIMIT.getKey(), 50)
         .build();
 
+    protected Collection<Class<? extends Plugin>> nodePlugins() {
+        return List.of(MockTransportService.TestPlugin.class);
+    }
+
     @Before
     public void init() {
         String clusterManagerNode = internalCluster().startClusterManagerOnlyNode(
@@ -79,6 +92,25 @@ public void init() {
 
         // Enable admission control
         client().admin().cluster().prepareUpdateSettings().setTransientSettings(ENFORCE_ADMISSION_CONTROL).execute().actionGet();
+        MockTransportService primaryService = (MockTransportService) internalCluster().getInstance(
+            TransportService.class,
+            clusterManagerNode
+        );
+
+        // Force always fetch from ClusterManager
+        ClusterService clusterService = internalCluster().clusterService();
+        GetTermVersionResponse oosTerm = new GetTermVersionResponse(
+            new ClusterStateTermVersion(
+                clusterService.state().getClusterName(),
+                clusterService.state().metadata().clusterUUID(),
+                clusterService.state().term() - 1,
+                clusterService.state().version() - 1
+            )
+        );
+        primaryService.addRequestHandlingBehavior(
+            GetTermVersionAction.NAME,
+            (handler, request, channel, task) -> channel.sendResponse(oosTerm)
+        );
     }
 
     public void testAdmissionControlEnforced() throws Exception {
@@ -86,8 +118,8 @@ public void testAdmissionControlEnforced() throws Exception {
 
         // Write API on ClusterManager
         assertAcked(prepareCreate("test").setMapping("field", "type=text").setAliases("{\"alias1\" : {}}"));
-
         // Read API on ClusterManager
+
         GetAliasesRequest aliasesRequest = new GetAliasesRequest();
         aliasesRequest.aliases("alias1");
         try {
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotemigration/MigrationBaseTestCase.java b/server/src/internalClusterTest/java/org/opensearch/remotemigration/MigrationBaseTestCase.java
index 2bea36ed80c9f..e4e681a5433b5 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotemigration/MigrationBaseTestCase.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotemigration/MigrationBaseTestCase.java
@@ -46,6 +46,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_REPLICAS;
 import static org.opensearch.cluster.routing.allocation.decider.EnableAllocationDecider.CLUSTER_ROUTING_REBALANCE_ENABLE_SETTING;
 import static org.opensearch.gateway.remote.RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING;
@@ -277,4 +278,30 @@ protected IndexShard getIndexShard(String dataNode, String indexName) throws Exe
         IndexService indexService = indicesService.indexService(new Index(indexName, uuid));
         return indexService.getShard(0);
     }
+
+    public void changeReplicaCountAndEnsureGreen(int replicaCount, String indexName) {
+        assertAcked(
+            client().admin()
+                .indices()
+                .prepareUpdateSettings(indexName)
+                .setSettings(Settings.builder().put(SETTING_NUMBER_OF_REPLICAS, replicaCount))
+        );
+        ensureGreen(indexName);
+    }
+
+    public void completeDocRepToRemoteMigration() {
+        assertTrue(
+            internalCluster().client()
+                .admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setPersistentSettings(
+                    Settings.builder()
+                        .putNull(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey())
+                        .putNull(MIGRATION_DIRECTION_SETTING.getKey())
+                )
+                .get()
+                .isAcknowledged()
+        );
+    }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteMigrationIndexMetadataUpdateIT.java b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteMigrationIndexMetadataUpdateIT.java
index 216c104dfecc1..b55219e1cb37f 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteMigrationIndexMetadataUpdateIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteMigrationIndexMetadataUpdateIT.java
@@ -546,6 +546,73 @@ public void testRemoteIndexPathFileExistsAfterMigration() throws Exception {
         assertTrue(Arrays.stream(files).anyMatch(file -> file.toString().contains(fileNamePrefix)));
     }
 
+    /**
+     * Scenario:
+     * Creates an index with 1 pri 1 rep setup with 3 docrep nodes (1 cluster manager + 2 data nodes),
+     * initiate migration and create 3 remote nodes (1 cluster manager + 2 data nodes) and moves over
+     * only primary shard copy of the index
+     * After the primary shard copy is relocated, decrease replica count to 0, stop all docrep nodes
+     * and conclude migration. Remote store index settings should be applied to the index at this point.
+     */
+    public void testIndexSettingsUpdateDuringReplicaCountDecrement() throws Exception {
+        String indexName = "migration-index-replica-decrement";
+        String docrepClusterManager = internalCluster().startClusterManagerOnlyNode();
+
+        logger.info("---> Starting 2 docrep nodes");
+        List<String> docrepNodeNames = internalCluster().startDataOnlyNodes(2);
+        internalCluster().validateClusterFormed();
+
+        logger.info("---> Creating index with 1 primary and 1 replica");
+        Settings oneReplica = Settings.builder()
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 1)
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .build();
+        createIndexAndAssertDocrepProperties(indexName, oneReplica);
+
+        int docsToIndex = randomIntBetween(10, 100);
+        logger.info("---> Indexing {} on both indices", docsToIndex);
+        indexBulk(indexName, docsToIndex);
+
+        logger.info(
+            "---> Stopping shard rebalancing to ensure shards do not automatically move over to newer nodes after they are launched"
+        );
+        stopShardRebalancing();
+
+        logger.info("---> Starting 3 remote store enabled nodes");
+        initDocRepToRemoteMigration();
+        setAddRemote(true);
+        internalCluster().startClusterManagerOnlyNode();
+        List<String> remoteNodeNames = internalCluster().startDataOnlyNodes(2);
+        internalCluster().validateClusterFormed();
+
+        String primaryNode = primaryNodeName(indexName);
+
+        logger.info("---> Moving over primary to remote store enabled nodes");
+        assertAcked(
+            client().admin()
+                .cluster()
+                .prepareReroute()
+                .add(new MoveAllocationCommand(indexName, 0, primaryNode, remoteNodeNames.get(0)))
+                .execute()
+                .actionGet()
+        );
+        waitForRelocation();
+        waitNoPendingTasksOnAll();
+
+        logger.info("---> Reducing replica count to 0 for the index");
+        changeReplicaCountAndEnsureGreen(0, indexName);
+
+        logger.info("---> Stopping all docrep nodes");
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(docrepClusterManager));
+        for (String node : docrepNodeNames) {
+            internalCluster().stopRandomNode(InternalTestCluster.nameFilter(node));
+        }
+        internalCluster().validateClusterFormed();
+        completeDocRepToRemoteMigration();
+        waitNoPendingTasksOnAll();
+        assertRemoteProperties(indexName);
+    }
+
     private void createIndexAndAssertDocrepProperties(String index, Settings settings) {
         createIndexAssertHealthAndDocrepProperties(index, settings, this::ensureGreen);
     }
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java
index 64efcee6ef1b5..63a9451a27a12 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java
@@ -69,6 +69,7 @@
 public class RemoteStoreBaseIntegTestCase extends OpenSearchIntegTestCase {
     protected static final String REPOSITORY_NAME = "test-remote-store-repo";
     protected static final String REPOSITORY_2_NAME = "test-remote-store-repo-2";
+    protected static final String REMOTE_ROUTING_TABLE_REPO = "remote-routing-table-repo";
     protected static final int SHARD_COUNT = 1;
     protected static int REPLICA_COUNT = 1;
     protected static final String TOTAL_OPERATIONS = "total-operations";
@@ -360,4 +361,20 @@ protected void prepareCluster(int numClusterManagerNodes, int numDataOnlyNodes,
             ensureGreen(index);
         }
     }
+
+    protected void prepareCluster(
+        int numClusterManagerNodes,
+        int numDataOnlyNodes,
+        String indices,
+        int replicaCount,
+        int shardCount,
+        Settings settings
+    ) {
+        internalCluster().startClusterManagerOnlyNodes(numClusterManagerNodes, settings);
+        internalCluster().startDataOnlyNodes(numDataOnlyNodes, settings);
+        for (String index : indices.split(",")) {
+            createIndex(index, remoteStoreIndexSettings(replicaCount, shardCount));
+            ensureGreen(index);
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/ActionModule.java b/server/src/main/java/org/opensearch/action/ActionModule.java
index 16c15f553951c..574b7029a6501 100644
--- a/server/src/main/java/org/opensearch/action/ActionModule.java
+++ b/server/src/main/java/org/opensearch/action/ActionModule.java
@@ -216,6 +216,9 @@
 import org.opensearch.action.admin.indices.template.put.TransportPutComponentTemplateAction;
 import org.opensearch.action.admin.indices.template.put.TransportPutComposableIndexTemplateAction;
 import org.opensearch.action.admin.indices.template.put.TransportPutIndexTemplateAction;
+import org.opensearch.action.admin.indices.tiering.HotToWarmTieringAction;
+import org.opensearch.action.admin.indices.tiering.RestWarmTieringAction;
+import org.opensearch.action.admin.indices.tiering.TransportHotToWarmTieringAction;
 import org.opensearch.action.admin.indices.upgrade.get.TransportUpgradeStatusAction;
 import org.opensearch.action.admin.indices.upgrade.get.UpgradeStatusAction;
 import org.opensearch.action.admin.indices.upgrade.post.TransportUpgradeAction;
@@ -634,6 +637,9 @@ public <Request extends ActionRequest, Response extends ActionResponse> void reg
         actions.register(CreateSnapshotAction.INSTANCE, TransportCreateSnapshotAction.class);
         actions.register(CloneSnapshotAction.INSTANCE, TransportCloneSnapshotAction.class);
         actions.register(RestoreSnapshotAction.INSTANCE, TransportRestoreSnapshotAction.class);
+        if (FeatureFlags.isEnabled(FeatureFlags.TIERED_REMOTE_INDEX)) {
+            actions.register(HotToWarmTieringAction.INSTANCE, TransportHotToWarmTieringAction.class);
+        }
         actions.register(SnapshotsStatusAction.INSTANCE, TransportSnapshotsStatusAction.class);
 
         actions.register(ClusterAddWeightedRoutingAction.INSTANCE, TransportAddWeightedRoutingAction.class);
@@ -966,6 +972,9 @@ public void initRestHandlers(Supplier<DiscoveryNodes> nodesInCluster) {
         registerHandler.accept(new RestNodeAttrsAction());
         registerHandler.accept(new RestRepositoriesAction());
         registerHandler.accept(new RestSnapshotAction());
+        if (FeatureFlags.isEnabled(FeatureFlags.TIERED_REMOTE_INDEX)) {
+            registerHandler.accept(new RestWarmTieringAction());
+        }
         registerHandler.accept(new RestTemplatesAction());
 
         // Point in time API
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/decommission/awareness/get/TransportGetDecommissionStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/decommission/awareness/get/TransportGetDecommissionStateAction.java
index 22feb4d99297a..c8a3be78a790e 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/decommission/awareness/get/TransportGetDecommissionStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/decommission/awareness/get/TransportGetDecommissionStateAction.java
@@ -48,7 +48,8 @@ public TransportGetDecommissionStateAction(
             threadPool,
             actionFilters,
             GetDecommissionStateRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/health/TransportClusterHealthAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/health/TransportClusterHealthAction.java
index 1cc357a4c20f4..f69f462372888 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/health/TransportClusterHealthAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/health/TransportClusterHealthAction.java
@@ -534,4 +534,9 @@ private ClusterHealthResponse clusterHealth(
             pendingTaskTimeInQueue
         );
     }
+
+    @Override
+    protected boolean localExecuteSupportedByAction() {
+        return false;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
index 2c4f8522a5a5c..dda54cce334ec 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
@@ -129,7 +129,7 @@ protected NodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
      */
     public static class NodeInfoRequest extends TransportRequest {
 
-        NodesInfoRequest request;
+        protected NodesInfoRequest request;
 
         public NodeInfoRequest(StreamInput in) throws IOException {
             super(in);
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/TransportNodesStatsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/TransportNodesStatsAction.java
index 2e93e5e7841cb..2c808adc97c7a 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/TransportNodesStatsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/TransportNodesStatsAction.java
@@ -140,7 +140,7 @@ protected NodeStats nodeOperation(NodeStatsRequest nodeStatsRequest) {
      */
     public static class NodeStatsRequest extends TransportRequest {
 
-        NodesStatsRequest request;
+        protected NodesStatsRequest request;
 
         public NodeStatsRequest(StreamInput in) throws IOException {
             super(in);
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/repositories/get/TransportGetRepositoriesAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/repositories/get/TransportGetRepositoriesAction.java
index c7d784dbc96e7..c99b52dfe34f4 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/repositories/get/TransportGetRepositoriesAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/repositories/get/TransportGetRepositoriesAction.java
@@ -79,7 +79,8 @@ public TransportGetRepositoriesAction(
             threadPool,
             actionFilters,
             GetRepositoriesRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/settings/TransportClusterUpdateSettingsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/settings/TransportClusterUpdateSettingsAction.java
index 216e1fb2ed1cc..3988d50b2ce1e 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/settings/TransportClusterUpdateSettingsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/settings/TransportClusterUpdateSettingsAction.java
@@ -42,7 +42,6 @@
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.block.ClusterBlockException;
 import org.opensearch.cluster.block.ClusterBlockLevel;
-import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
@@ -59,17 +58,13 @@
 import org.opensearch.common.settings.SettingsException;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.io.stream.StreamInput;
-import org.opensearch.index.remote.RemoteMigrationIndexMetadataUpdater;
 import org.opensearch.node.remotestore.RemoteStoreNodeService;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
-import java.util.Collection;
-import java.util.Set;
-import java.util.stream.Collectors;
 
-import static org.opensearch.index.remote.RemoteMigrationIndexMetadataUpdater.indexHasAllRemoteStoreRelatedMetadata;
+import static org.opensearch.index.remote.RemoteStoreUtils.checkAndFinalizeRemoteStoreMigration;
 
 /**
  * Transport action for updating cluster settings
@@ -262,13 +257,14 @@ public void onFailure(String source, Exception e) {
 
                 @Override
                 public ClusterState execute(final ClusterState currentState) {
-                    validateCompatibilityModeSettingRequest(request, state);
-                    final ClusterState clusterState = updater.updateSettings(
+                    boolean isCompatibilityModeChanging = validateCompatibilityModeSettingRequest(request, state);
+                    ClusterState clusterState = updater.updateSettings(
                         currentState,
                         clusterSettings.upgradeSettings(request.transientSettings()),
                         clusterSettings.upgradeSettings(request.persistentSettings()),
                         logger
                     );
+                    clusterState = checkAndFinalizeRemoteStoreMigration(isCompatibilityModeChanging, request, clusterState, logger);
                     changed = clusterState != currentState;
                     return clusterState;
                 }
@@ -278,19 +274,23 @@ public ClusterState execute(final ClusterState currentState) {
 
     /**
      * Runs various checks associated with changing cluster compatibility mode
+     *
      * @param request cluster settings update request, for settings to be updated and new values
      * @param clusterState current state of cluster, for information on nodes
+     * @return true if the incoming cluster settings update request is switching compatibility modes
      */
-    public void validateCompatibilityModeSettingRequest(ClusterUpdateSettingsRequest request, ClusterState clusterState) {
+    public boolean validateCompatibilityModeSettingRequest(ClusterUpdateSettingsRequest request, ClusterState clusterState) {
         Settings settings = Settings.builder().put(request.persistentSettings()).put(request.transientSettings()).build();
         if (RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING.exists(settings)) {
-            String value = RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING.get(settings).mode;
             validateAllNodesOfSameVersion(clusterState.nodes());
-            if (RemoteStoreNodeService.CompatibilityMode.STRICT.mode.equals(value)) {
+            if (RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING.get(
+                settings
+            ) == RemoteStoreNodeService.CompatibilityMode.STRICT) {
                 validateAllNodesOfSameType(clusterState.nodes());
-                validateIndexSettings(clusterState);
             }
+            return true;
         }
+        return false;
     }
 
     /**
@@ -310,31 +310,18 @@ private void validateAllNodesOfSameVersion(DiscoveryNodes discoveryNodes) {
      * @param discoveryNodes current discovery nodes in the cluster
      */
     private void validateAllNodesOfSameType(DiscoveryNodes discoveryNodes) {
-        Set<Boolean> nodeTypes = discoveryNodes.getNodes()
+        boolean allNodesDocrepEnabled = discoveryNodes.getNodes()
             .values()
             .stream()
-            .map(DiscoveryNode::isRemoteStoreNode)
-            .collect(Collectors.toSet());
-        if (nodeTypes.size() != 1) {
+            .allMatch(discoveryNode -> discoveryNode.isRemoteStoreNode() == false);
+        boolean allNodesRemoteStoreEnabled = discoveryNodes.getNodes()
+            .values()
+            .stream()
+            .allMatch(discoveryNode -> discoveryNode.isRemoteStoreNode());
+        if (allNodesDocrepEnabled == false && allNodesRemoteStoreEnabled == false) {
             throw new SettingsException(
                 "can not switch to STRICT compatibility mode when the cluster contains both remote and non-remote nodes"
             );
         }
     }
-
-    /**
-     * Verifies that while trying to switch to STRICT compatibility mode,
-     * all indices in the cluster have {@link RemoteMigrationIndexMetadataUpdater#indexHasAllRemoteStoreRelatedMetadata(IndexMetadata)} as <code>true</code>.
-     * If not, throws {@link SettingsException}
-     * @param clusterState current cluster state
-     */
-    private void validateIndexSettings(ClusterState clusterState) {
-        Collection<IndexMetadata> allIndicesMetadata = clusterState.metadata().indices().values();
-        if (allIndicesMetadata.isEmpty() == false
-            && allIndicesMetadata.stream().anyMatch(indexMetadata -> indexHasAllRemoteStoreRelatedMetadata(indexMetadata) == false)) {
-            throw new SettingsException(
-                "can not switch to STRICT compatibility mode since all indices in the cluster does not have remote store based index settings"
-            );
-        }
-    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportClusterSearchShardsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportClusterSearchShardsAction.java
index a2a65b6400c97..83e104236f640 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportClusterSearchShardsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportClusterSearchShardsAction.java
@@ -85,7 +85,8 @@ public TransportClusterSearchShardsAction(
             threadPool,
             actionFilters,
             ClusterSearchShardsRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
         this.indicesService = indicesService;
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/shards/routing/weighted/get/TransportGetWeightedRoutingAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/shards/routing/weighted/get/TransportGetWeightedRoutingAction.java
index 50368d85e0011..6c110c0ea2a73 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/shards/routing/weighted/get/TransportGetWeightedRoutingAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/shards/routing/weighted/get/TransportGetWeightedRoutingAction.java
@@ -55,7 +55,8 @@ public TransportGetWeightedRoutingAction(
             threadPool,
             actionFilters,
             ClusterGetWeightedRoutingRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
         this.weightedRoutingService = weightedRoutingService;
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
index cae465a90446e..13ea7eaa43bf8 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
@@ -92,6 +92,7 @@ public TransportClusterStateAction(
             ClusterStateRequest::new,
             indexNameExpressionResolver
         );
+        this.localExecuteSupported = true;
     }
 
     @Override
@@ -233,9 +234,4 @@ private ClusterStateResponse buildResponse(final ClusterStateRequest request, fi
 
         return new ClusterStateResponse(currentState.getClusterName(), builder.build(), false);
     }
-
-    @Override
-    protected boolean localExecuteSupportedByAction() {
-        return true;
-    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIndices.java b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIndices.java
index 26e554f44fca1..03a73f45ffe81 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIndices.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIndices.java
@@ -78,26 +78,49 @@ public ClusterStatsIndices(List<ClusterStatsNodeResponse> nodeResponses, Mapping
         this.segments = new SegmentsStats();
 
         for (ClusterStatsNodeResponse r : nodeResponses) {
-            for (org.opensearch.action.admin.indices.stats.ShardStats shardStats : r.shardsStats()) {
-                ShardStats indexShardStats = countsPerIndex.get(shardStats.getShardRouting().getIndexName());
-                if (indexShardStats == null) {
-                    indexShardStats = new ShardStats();
-                    countsPerIndex.put(shardStats.getShardRouting().getIndexName(), indexShardStats);
+            // Aggregated response from the node
+            if (r.getAggregatedNodeLevelStats() != null) {
+
+                for (Map.Entry<String, ClusterStatsNodeResponse.AggregatedIndexStats> entry : r.getAggregatedNodeLevelStats().indexStatsMap
+                    .entrySet()) {
+                    ShardStats indexShardStats = countsPerIndex.get(entry.getKey());
+                    if (indexShardStats == null) {
+                        indexShardStats = new ShardStats(entry.getValue());
+                        countsPerIndex.put(entry.getKey(), indexShardStats);
+                    } else {
+                        indexShardStats.addStatsFrom(entry.getValue());
+                    }
                 }
 
-                indexShardStats.total++;
-
-                CommonStats shardCommonStats = shardStats.getStats();
-
-                if (shardStats.getShardRouting().primary()) {
-                    indexShardStats.primaries++;
-                    docs.add(shardCommonStats.docs);
+                docs.add(r.getAggregatedNodeLevelStats().commonStats.docs);
+                store.add(r.getAggregatedNodeLevelStats().commonStats.store);
+                fieldData.add(r.getAggregatedNodeLevelStats().commonStats.fieldData);
+                queryCache.add(r.getAggregatedNodeLevelStats().commonStats.queryCache);
+                completion.add(r.getAggregatedNodeLevelStats().commonStats.completion);
+                segments.add(r.getAggregatedNodeLevelStats().commonStats.segments);
+            } else {
+                // Default response from the node
+                for (org.opensearch.action.admin.indices.stats.ShardStats shardStats : r.shardsStats()) {
+                    ShardStats indexShardStats = countsPerIndex.get(shardStats.getShardRouting().getIndexName());
+                    if (indexShardStats == null) {
+                        indexShardStats = new ShardStats();
+                        countsPerIndex.put(shardStats.getShardRouting().getIndexName(), indexShardStats);
+                    }
+
+                    indexShardStats.total++;
+
+                    CommonStats shardCommonStats = shardStats.getStats();
+
+                    if (shardStats.getShardRouting().primary()) {
+                        indexShardStats.primaries++;
+                        docs.add(shardCommonStats.docs);
+                    }
+                    store.add(shardCommonStats.store);
+                    fieldData.add(shardCommonStats.fieldData);
+                    queryCache.add(shardCommonStats.queryCache);
+                    completion.add(shardCommonStats.completion);
+                    segments.add(shardCommonStats.segments);
                 }
-                store.add(shardCommonStats.store);
-                fieldData.add(shardCommonStats.fieldData);
-                queryCache.add(shardCommonStats.queryCache);
-                completion.add(shardCommonStats.completion);
-                segments.add(shardCommonStats.segments);
             }
         }
 
@@ -202,6 +225,11 @@ public static class ShardStats implements ToXContentFragment {
 
         public ShardStats() {}
 
+        public ShardStats(ClusterStatsNodeResponse.AggregatedIndexStats aggregatedIndexStats) {
+            this.total = aggregatedIndexStats.total;
+            this.primaries = aggregatedIndexStats.primaries;
+        }
+
         /**
          * number of indices in the cluster
          */
@@ -329,6 +357,11 @@ public void addIndexShardCount(ShardStats indexShardCount) {
             }
         }
 
+        public void addStatsFrom(ClusterStatsNodeResponse.AggregatedIndexStats incomingStats) {
+            this.total += incomingStats.total;
+            this.primaries += incomingStats.primaries;
+        }
+
         /**
          * Inner Fields used for creating XContent and parsing
          *
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodeResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodeResponse.java
index 1b25bf84356d6..133cf68f5f8c9 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodeResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodeResponse.java
@@ -32,17 +32,29 @@
 
 package org.opensearch.action.admin.cluster.stats;
 
+import org.opensearch.Version;
 import org.opensearch.action.admin.cluster.node.info.NodeInfo;
 import org.opensearch.action.admin.cluster.node.stats.NodeStats;
+import org.opensearch.action.admin.indices.stats.CommonStats;
 import org.opensearch.action.admin.indices.stats.ShardStats;
 import org.opensearch.action.support.nodes.BaseNodeResponse;
 import org.opensearch.cluster.health.ClusterHealthStatus;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Nullable;
+import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.index.cache.query.QueryCacheStats;
+import org.opensearch.index.engine.SegmentsStats;
+import org.opensearch.index.fielddata.FieldDataStats;
+import org.opensearch.index.shard.DocsStats;
+import org.opensearch.index.store.StoreStats;
+import org.opensearch.search.suggest.completion.CompletionStats;
 
 import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
 
 /**
  * Transport action for obtaining cluster stats from node level
@@ -55,6 +67,7 @@ public class ClusterStatsNodeResponse extends BaseNodeResponse {
     private final NodeStats nodeStats;
     private final ShardStats[] shardsStats;
     private ClusterHealthStatus clusterStatus;
+    private AggregatedNodeLevelStats aggregatedNodeLevelStats;
 
     public ClusterStatsNodeResponse(StreamInput in) throws IOException {
         super(in);
@@ -64,7 +77,12 @@ public ClusterStatsNodeResponse(StreamInput in) throws IOException {
         }
         this.nodeInfo = new NodeInfo(in);
         this.nodeStats = new NodeStats(in);
-        shardsStats = in.readArray(ShardStats::new, ShardStats[]::new);
+        if (in.getVersion().onOrAfter(Version.V_3_0_0)) {
+            this.shardsStats = in.readOptionalArray(ShardStats::new, ShardStats[]::new);
+            this.aggregatedNodeLevelStats = in.readOptionalWriteable(AggregatedNodeLevelStats::new);
+        } else {
+            this.shardsStats = in.readArray(ShardStats::new, ShardStats[]::new);
+        }
     }
 
     public ClusterStatsNodeResponse(
@@ -81,6 +99,24 @@ public ClusterStatsNodeResponse(
         this.clusterStatus = clusterStatus;
     }
 
+    public ClusterStatsNodeResponse(
+        DiscoveryNode node,
+        @Nullable ClusterHealthStatus clusterStatus,
+        NodeInfo nodeInfo,
+        NodeStats nodeStats,
+        ShardStats[] shardsStats,
+        boolean useAggregatedNodeLevelResponses
+    ) {
+        super(node);
+        this.nodeInfo = nodeInfo;
+        this.nodeStats = nodeStats;
+        if (useAggregatedNodeLevelResponses) {
+            this.aggregatedNodeLevelStats = new AggregatedNodeLevelStats(node, shardsStats);
+        }
+        this.shardsStats = shardsStats;
+        this.clusterStatus = clusterStatus;
+    }
+
     public NodeInfo nodeInfo() {
         return this.nodeInfo;
     }
@@ -101,6 +137,10 @@ public ShardStats[] shardsStats() {
         return this.shardsStats;
     }
 
+    public AggregatedNodeLevelStats getAggregatedNodeLevelStats() {
+        return aggregatedNodeLevelStats;
+    }
+
     public static ClusterStatsNodeResponse readNodeResponse(StreamInput in) throws IOException {
         return new ClusterStatsNodeResponse(in);
     }
@@ -116,6 +156,95 @@ public void writeTo(StreamOutput out) throws IOException {
         }
         nodeInfo.writeTo(out);
         nodeStats.writeTo(out);
-        out.writeArray(shardsStats);
+        if (out.getVersion().onOrAfter(Version.V_3_0_0)) {
+            if (aggregatedNodeLevelStats != null) {
+                out.writeOptionalArray(null);
+                out.writeOptionalWriteable(aggregatedNodeLevelStats);
+            } else {
+                out.writeOptionalArray(shardsStats);
+                out.writeOptionalWriteable(null);
+            }
+        } else {
+            out.writeArray(shardsStats);
+        }
+    }
+
+    /**
+     * Node level statistics used for ClusterStatsIndices for _cluster/stats call.
+     */
+    public class AggregatedNodeLevelStats extends BaseNodeResponse {
+
+        CommonStats commonStats;
+        Map<String, AggregatedIndexStats> indexStatsMap;
+
+        protected AggregatedNodeLevelStats(StreamInput in) throws IOException {
+            super(in);
+            commonStats = in.readOptionalWriteable(CommonStats::new);
+            indexStatsMap = in.readMap(StreamInput::readString, AggregatedIndexStats::new);
+        }
+
+        protected AggregatedNodeLevelStats(DiscoveryNode node, ShardStats[] indexShardsStats) {
+            super(node);
+            this.commonStats = new CommonStats();
+            this.commonStats.docs = new DocsStats();
+            this.commonStats.store = new StoreStats();
+            this.commonStats.fieldData = new FieldDataStats();
+            this.commonStats.queryCache = new QueryCacheStats();
+            this.commonStats.completion = new CompletionStats();
+            this.commonStats.segments = new SegmentsStats();
+            this.indexStatsMap = new HashMap<>();
+
+            // Index Level Stats
+            for (org.opensearch.action.admin.indices.stats.ShardStats shardStats : indexShardsStats) {
+                AggregatedIndexStats indexShardStats = this.indexStatsMap.get(shardStats.getShardRouting().getIndexName());
+                if (indexShardStats == null) {
+                    indexShardStats = new AggregatedIndexStats();
+                    this.indexStatsMap.put(shardStats.getShardRouting().getIndexName(), indexShardStats);
+                }
+
+                indexShardStats.total++;
+
+                CommonStats shardCommonStats = shardStats.getStats();
+
+                if (shardStats.getShardRouting().primary()) {
+                    indexShardStats.primaries++;
+                    this.commonStats.docs.add(shardCommonStats.docs);
+                }
+                this.commonStats.store.add(shardCommonStats.store);
+                this.commonStats.fieldData.add(shardCommonStats.fieldData);
+                this.commonStats.queryCache.add(shardCommonStats.queryCache);
+                this.commonStats.completion.add(shardCommonStats.completion);
+                this.commonStats.segments.add(shardCommonStats.segments);
+            }
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            super.writeTo(out);
+            out.writeOptionalWriteable(commonStats);
+            out.writeMap(indexStatsMap, StreamOutput::writeString, (stream, stats) -> stats.writeTo(stream));
+        }
+    }
+
+    /**
+     * Node level statistics used for ClusterStatsIndices for _cluster/stats call.
+     */
+    @PublicApi(since = "2.16.0")
+    public static class AggregatedIndexStats implements Writeable {
+        public int total = 0;
+        public int primaries = 0;
+
+        public AggregatedIndexStats(StreamInput in) throws IOException {
+            total = in.readVInt();
+            primaries = in.readVInt();
+        }
+
+        public AggregatedIndexStats() {}
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            out.writeVInt(total);
+            out.writeVInt(primaries);
+        }
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequest.java
index 6a99451c596ed..fdeb82a3466f2 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequest.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.action.admin.cluster.stats;
 
+import org.opensearch.Version;
 import org.opensearch.action.support.nodes.BaseNodesRequest;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.core.common.io.stream.StreamInput;
@@ -49,8 +50,13 @@ public class ClusterStatsRequest extends BaseNodesRequest<ClusterStatsRequest> {
 
     public ClusterStatsRequest(StreamInput in) throws IOException {
         super(in);
+        if (in.getVersion().onOrAfter(Version.V_3_0_0)) {
+            useAggregatedNodeLevelResponses = in.readOptionalBoolean();
+        }
     }
 
+    private Boolean useAggregatedNodeLevelResponses = false;
+
     /**
      * Get stats from nodes based on the nodes ids specified. If none are passed, stats
      * based on all nodes will be returned.
@@ -59,9 +65,20 @@ public ClusterStatsRequest(String... nodesIds) {
         super(nodesIds);
     }
 
+    public boolean useAggregatedNodeLevelResponses() {
+        return useAggregatedNodeLevelResponses;
+    }
+
+    public void useAggregatedNodeLevelResponses(boolean useAggregatedNodeLevelResponses) {
+        this.useAggregatedNodeLevelResponses = useAggregatedNodeLevelResponses;
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         super.writeTo(out);
+        if (out.getVersion().onOrAfter(Version.V_3_0_0)) {
+            out.writeOptionalBoolean(useAggregatedNodeLevelResponses);
+        }
     }
 
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequestBuilder.java b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequestBuilder.java
index 0dcb03dc26d0e..4d0932bd3927d 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequestBuilder.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequestBuilder.java
@@ -50,4 +50,9 @@ public class ClusterStatsRequestBuilder extends NodesOperationRequestBuilder<
     public ClusterStatsRequestBuilder(OpenSearchClient client, ClusterStatsAction action) {
         super(client, action, new ClusterStatsRequest());
     }
+
+    public final ClusterStatsRequestBuilder useAggregatedNodeLevelResponses(boolean useAggregatedNodeLevelResponses) {
+        request.useAggregatedNodeLevelResponses(useAggregatedNodeLevelResponses);
+        return this;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/stats/TransportClusterStatsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/stats/TransportClusterStatsAction.java
index e4f483f796f44..be7d41a7ba75e 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/stats/TransportClusterStatsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/stats/TransportClusterStatsAction.java
@@ -212,8 +212,14 @@ protected ClusterStatsNodeResponse nodeOperation(ClusterStatsNodeRequest nodeReq
             clusterStatus = new ClusterStateHealth(clusterService.state()).getStatus();
         }
 
-        return new ClusterStatsNodeResponse(nodeInfo.getNode(), clusterStatus, nodeInfo, nodeStats, shardsStats.toArray(new ShardStats[0]));
-
+        return new ClusterStatsNodeResponse(
+            nodeInfo.getNode(),
+            clusterStatus,
+            nodeInfo,
+            nodeStats,
+            shardsStats.toArray(new ShardStats[0]),
+            nodeRequest.request.useAggregatedNodeLevelResponses()
+        );
     }
 
     /**
@@ -223,7 +229,7 @@ protected ClusterStatsNodeResponse nodeOperation(ClusterStatsNodeRequest nodeReq
      */
     public static class ClusterStatsNodeRequest extends TransportRequest {
 
-        ClusterStatsRequest request;
+        protected ClusterStatsRequest request;
 
         public ClusterStatsNodeRequest(StreamInput in) throws IOException {
             super(in);
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/storedscripts/TransportGetStoredScriptAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/storedscripts/TransportGetStoredScriptAction.java
index db1f1edde2812..c34ec49406802 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/storedscripts/TransportGetStoredScriptAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/storedscripts/TransportGetStoredScriptAction.java
@@ -73,7 +73,8 @@ public TransportGetStoredScriptAction(
             threadPool,
             actionFilters,
             GetStoredScriptRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
         this.scriptService = scriptService;
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/tasks/TransportPendingClusterTasksAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/tasks/TransportPendingClusterTasksAction.java
index 5d5053cc80738..01846ef46c1ed 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/tasks/TransportPendingClusterTasksAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/tasks/TransportPendingClusterTasksAction.java
@@ -110,4 +110,9 @@ protected void clusterManagerOperation(
         logger.trace("done fetching pending tasks from cluster service");
         listener.onResponse(new PendingClusterTasksResponse(pendingTasks));
     }
+
+    @Override
+    protected boolean localExecuteSupportedByAction() {
+        return false;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/alias/get/TransportGetAliasesAction.java b/server/src/main/java/org/opensearch/action/admin/indices/alias/get/TransportGetAliasesAction.java
index 3aca9c1976f16..4f4e3bd481ee7 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/alias/get/TransportGetAliasesAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/alias/get/TransportGetAliasesAction.java
@@ -86,7 +86,8 @@ public TransportGetAliasesAction(
             threadPool,
             actionFilters,
             GetAliasesRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
         this.systemIndices = systemIndices;
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/exists/indices/TransportIndicesExistsAction.java b/server/src/main/java/org/opensearch/action/admin/indices/exists/indices/TransportIndicesExistsAction.java
index 428a0eb35513d..a298eae1aa865 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/exists/indices/TransportIndicesExistsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/exists/indices/TransportIndicesExistsAction.java
@@ -71,7 +71,8 @@ public TransportIndicesExistsAction(
             threadPool,
             actionFilters,
             IndicesExistsRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/shards/TransportIndicesShardStoresAction.java b/server/src/main/java/org/opensearch/action/admin/indices/shards/TransportIndicesShardStoresAction.java
index 3fbf9ac1bb570..a8b97d0f344ae 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/shards/TransportIndicesShardStoresAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/shards/TransportIndicesShardStoresAction.java
@@ -105,7 +105,8 @@ public TransportIndicesShardStoresAction(
             threadPool,
             actionFilters,
             IndicesShardStoresRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
         this.listShardStoresInfo = listShardStoresInfo;
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComponentTemplateAction.java b/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComponentTemplateAction.java
index e2594cd792cd3..c3217d109044d 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComponentTemplateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComponentTemplateAction.java
@@ -76,7 +76,8 @@ public TransportGetComponentTemplateAction(
             threadPool,
             actionFilters,
             GetComponentTemplateAction.Request::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComposableIndexTemplateAction.java b/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComposableIndexTemplateAction.java
index b1ef32db7274f..84fbb59481c10 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComposableIndexTemplateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComposableIndexTemplateAction.java
@@ -76,7 +76,8 @@ public TransportGetComposableIndexTemplateAction(
             threadPool,
             actionFilters,
             GetComposableIndexTemplateAction.Request::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetIndexTemplatesAction.java b/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetIndexTemplatesAction.java
index 10b4975f7b9d0..522234dda509f 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetIndexTemplatesAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetIndexTemplatesAction.java
@@ -76,7 +76,8 @@ public TransportGetIndexTemplatesAction(
             threadPool,
             actionFilters,
             GetIndexTemplatesRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringAction.java b/server/src/main/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringAction.java
new file mode 100644
index 0000000000000..ae34a9a734221
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringAction.java
@@ -0,0 +1,28 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.opensearch.action.ActionType;
+import org.opensearch.common.annotation.ExperimentalApi;
+
+/**
+ * Tiering action to move indices from hot to warm
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class HotToWarmTieringAction extends ActionType<HotToWarmTieringResponse> {
+
+    public static final HotToWarmTieringAction INSTANCE = new HotToWarmTieringAction();
+    public static final String NAME = "indices:admin/tier/hot_to_warm";
+
+    private HotToWarmTieringAction() {
+        super(NAME, HotToWarmTieringResponse::new);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringResponse.java b/server/src/main/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringResponse.java
new file mode 100644
index 0000000000000..275decf7a8ea5
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringResponse.java
@@ -0,0 +1,157 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.opensearch.action.support.master.AcknowledgedResponse;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.common.Strings;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.MediaTypeRegistry;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * Response object for an {@link TieringIndexRequest} which is sent to client after the initial verification of the request
+ * by the backend service. The format of the response object will be as below:
+ *
+ *  {
+ *     "acknowledged": true/false,
+ *     "failed_indices": [
+ *              {
+ *                "index": "index1",
+ *                "error": "Low disk threshold watermark breached"
+ *              },
+ *              {
+ *                "index": "index2",
+ *                "error": "Index is not a remote store backed index"
+ *              }
+ *     ]
+ *  }
+ *
+ *  @opensearch.experimental
+ */
+@ExperimentalApi
+public class HotToWarmTieringResponse extends AcknowledgedResponse {
+
+    private final List<IndexResult> failedIndices;
+
+    public HotToWarmTieringResponse(boolean acknowledged) {
+        super(acknowledged);
+        this.failedIndices = Collections.emptyList();
+    }
+
+    public HotToWarmTieringResponse(boolean acknowledged, List<IndexResult> indicesResults) {
+        super(acknowledged);
+        this.failedIndices = (indicesResults == null)
+            ? Collections.emptyList()
+            : indicesResults.stream().sorted(Comparator.comparing(IndexResult::getIndex)).collect(Collectors.toList());
+    }
+
+    public HotToWarmTieringResponse(StreamInput in) throws IOException {
+        super(in);
+        failedIndices = Collections.unmodifiableList(in.readList(IndexResult::new));
+    }
+
+    public List<IndexResult> getFailedIndices() {
+        return this.failedIndices;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        super.writeTo(out);
+        out.writeList(this.failedIndices);
+    }
+
+    @Override
+    protected void addCustomFields(XContentBuilder builder, Params params) throws IOException {
+        super.addCustomFields(builder, params);
+        builder.startArray("failed_indices");
+
+        for (IndexResult failedIndex : failedIndices) {
+            failedIndex.toXContent(builder, params);
+        }
+        builder.endArray();
+    }
+
+    @Override
+    public String toString() {
+        return Strings.toString(MediaTypeRegistry.JSON, this);
+    }
+
+    /**
+     * Inner class to represent the result of a failed index for tiering.
+     * @opensearch.experimental
+     */
+    @ExperimentalApi
+    public static class IndexResult implements Writeable, ToXContentFragment {
+        private final String index;
+        private final String failureReason;
+
+        public IndexResult(String index, String failureReason) {
+            this.index = index;
+            this.failureReason = failureReason;
+        }
+
+        IndexResult(StreamInput in) throws IOException {
+            this.index = in.readString();
+            this.failureReason = in.readString();
+        }
+
+        public String getIndex() {
+            return index;
+        }
+
+        public String getFailureReason() {
+            return failureReason;
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            out.writeString(index);
+            out.writeString(failureReason);
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.startObject();
+            builder.field("index", index);
+            builder.field("error", failureReason);
+            return builder.endObject();
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            IndexResult that = (IndexResult) o;
+            return Objects.equals(index, that.index) && Objects.equals(failureReason, that.failureReason);
+        }
+
+        @Override
+        public int hashCode() {
+            int result = Objects.hashCode(index);
+            result = 31 * result + Objects.hashCode(failureReason);
+            return result;
+        }
+
+        @Override
+        public String toString() {
+            return Strings.toString(MediaTypeRegistry.JSON, this);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/tiering/RestWarmTieringAction.java b/server/src/main/java/org/opensearch/action/admin/indices/tiering/RestWarmTieringAction.java
new file mode 100644
index 0000000000000..6f2eceafa9e77
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/tiering/RestWarmTieringAction.java
@@ -0,0 +1,61 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.opensearch.action.support.IndicesOptions;
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.rest.BaseRestHandler;
+import org.opensearch.rest.RestHandler;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.action.RestToXContentListener;
+
+import java.util.List;
+
+import static java.util.Collections.singletonList;
+import static org.opensearch.core.common.Strings.splitStringByCommaToArray;
+import static org.opensearch.rest.RestRequest.Method.POST;
+
+/**
+ * Rest Tiering API action to move indices to warm tier
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class RestWarmTieringAction extends BaseRestHandler {
+
+    private static final String TARGET_TIER = "warm";
+
+    @Override
+    public List<RestHandler.Route> routes() {
+        return singletonList(new RestHandler.Route(POST, "/{index}/_tier/" + TARGET_TIER));
+    }
+
+    @Override
+    public String getName() {
+        return "warm_tiering_action";
+    }
+
+    @Override
+    protected BaseRestHandler.RestChannelConsumer prepareRequest(RestRequest request, NodeClient client) {
+        final TieringIndexRequest tieringIndexRequest = new TieringIndexRequest(
+            TARGET_TIER,
+            splitStringByCommaToArray(request.param("index"))
+        );
+        tieringIndexRequest.timeout(request.paramAsTime("timeout", tieringIndexRequest.timeout()));
+        tieringIndexRequest.clusterManagerNodeTimeout(
+            request.paramAsTime("cluster_manager_timeout", tieringIndexRequest.clusterManagerNodeTimeout())
+        );
+        tieringIndexRequest.indicesOptions(IndicesOptions.fromRequest(request, tieringIndexRequest.indicesOptions()));
+        tieringIndexRequest.waitForCompletion(request.paramAsBoolean("wait_for_completion", tieringIndexRequest.waitForCompletion()));
+        return channel -> client.admin()
+            .cluster()
+            .execute(HotToWarmTieringAction.INSTANCE, tieringIndexRequest, new RestToXContentListener<>(channel));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/tiering/TieringIndexRequest.java b/server/src/main/java/org/opensearch/action/admin/indices/tiering/TieringIndexRequest.java
new file mode 100644
index 0000000000000..ed458a47ddb7d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/tiering/TieringIndexRequest.java
@@ -0,0 +1,195 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.action.IndicesRequest;
+import org.opensearch.action.support.IndicesOptions;
+import org.opensearch.action.support.master.AcknowledgedRequest;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.Objects;
+
+import static org.opensearch.action.ValidateActions.addValidationError;
+
+/**
+ * Represents the tiering request for indices to move to a different tier
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class TieringIndexRequest extends AcknowledgedRequest<TieringIndexRequest> implements IndicesRequest.Replaceable {
+
+    private String[] indices;
+    private final Tier targetTier;
+    private IndicesOptions indicesOptions;
+    private boolean waitForCompletion;
+
+    public TieringIndexRequest(String targetTier, String... indices) {
+        this.targetTier = Tier.fromString(targetTier);
+        this.indices = indices;
+        this.indicesOptions = IndicesOptions.fromOptions(false, false, true, false);
+        this.waitForCompletion = false;
+    }
+
+    public TieringIndexRequest(StreamInput in) throws IOException {
+        super(in);
+        indices = in.readStringArray();
+        targetTier = Tier.fromString(in.readString());
+        indicesOptions = IndicesOptions.readIndicesOptions(in);
+        waitForCompletion = in.readBoolean();
+    }
+
+    // pkg private for testing
+    TieringIndexRequest(Tier targetTier, IndicesOptions indicesOptions, boolean waitForCompletion, String... indices) {
+        this.indices = indices;
+        this.targetTier = targetTier;
+        this.indicesOptions = indicesOptions;
+        this.waitForCompletion = waitForCompletion;
+    }
+
+    @Override
+    public ActionRequestValidationException validate() {
+        ActionRequestValidationException validationException = null;
+        if (indices == null) {
+            validationException = addValidationError("Mandatory parameter - indices is missing from the request", validationException);
+        } else {
+            for (String index : indices) {
+                if (index == null || index.length() == 0) {
+                    validationException = addValidationError(
+                        String.format(Locale.ROOT, "Specified index in the request [%s] is null or empty", index),
+                        validationException
+                    );
+                }
+            }
+        }
+        if (!Tier.WARM.equals(targetTier)) {
+            validationException = addValidationError("The specified tier is not supported", validationException);
+        }
+        return validationException;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        super.writeTo(out);
+        out.writeStringArray(indices);
+        out.writeString(targetTier.value());
+        indicesOptions.writeIndicesOptions(out);
+        out.writeBoolean(waitForCompletion);
+    }
+
+    @Override
+    public String[] indices() {
+        return indices;
+    }
+
+    @Override
+    public IndicesOptions indicesOptions() {
+        return indicesOptions;
+    }
+
+    @Override
+    public boolean includeDataStreams() {
+        return true;
+    }
+
+    @Override
+    public TieringIndexRequest indices(String... indices) {
+        this.indices = indices;
+        return this;
+    }
+
+    public TieringIndexRequest indicesOptions(IndicesOptions indicesOptions) {
+        this.indicesOptions = indicesOptions;
+        return this;
+    }
+
+    /**
+     * If this parameter is set to true the operation will wait for completion of tiering process before returning.
+     *
+     * @param waitForCompletion if true the operation will wait for completion
+     * @return this request
+     */
+    public TieringIndexRequest waitForCompletion(boolean waitForCompletion) {
+        this.waitForCompletion = waitForCompletion;
+        return this;
+    }
+
+    /**
+     * Returns wait for completion setting
+     *
+     * @return true if the operation will wait for completion
+     */
+    public boolean waitForCompletion() {
+        return waitForCompletion;
+    }
+
+    public Tier tier() {
+        return targetTier;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        TieringIndexRequest that = (TieringIndexRequest) o;
+        return clusterManagerNodeTimeout.equals(that.clusterManagerNodeTimeout)
+            && timeout.equals(that.timeout)
+            && Objects.equals(indicesOptions, that.indicesOptions)
+            && Arrays.equals(indices, that.indices)
+            && targetTier.equals(that.targetTier)
+            && waitForCompletion == that.waitForCompletion;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(clusterManagerNodeTimeout, timeout, indicesOptions, waitForCompletion, Arrays.hashCode(indices));
+    }
+
+    /**
+     * Represents the supported tiers for an index
+     *
+     * @opensearch.experimental
+     */
+    @ExperimentalApi
+    public enum Tier {
+        HOT,
+        WARM;
+
+        public static Tier fromString(String name) {
+            if (name == null) {
+                throw new IllegalArgumentException("Tiering type cannot be null");
+            }
+            String upperCase = name.trim().toUpperCase(Locale.ROOT);
+            switch (upperCase) {
+                case "HOT":
+                    return HOT;
+                case "WARM":
+                    return WARM;
+                default:
+                    throw new IllegalArgumentException(
+                        "Tiering type [" + name + "] is not supported. Supported types are " + HOT + " and " + WARM
+                    );
+            }
+        }
+
+        public String value() {
+            return name().toLowerCase(Locale.ROOT);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/tiering/TieringValidationResult.java b/server/src/main/java/org/opensearch/action/admin/indices/tiering/TieringValidationResult.java
new file mode 100644
index 0000000000000..ccd60daf027ce
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/tiering/TieringValidationResult.java
@@ -0,0 +1,83 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.index.Index;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Validation result for tiering
+ *
+ * @opensearch.experimental
+ */
+
+@ExperimentalApi
+public class TieringValidationResult {
+    private final Set<Index> acceptedIndices;
+    private final Map<Index, String> rejectedIndices;
+
+    public TieringValidationResult(Set<Index> concreteIndices) {
+        // by default all the indices are added to the accepted set
+        this.acceptedIndices = ConcurrentHashMap.newKeySet();
+        acceptedIndices.addAll(concreteIndices);
+        this.rejectedIndices = new HashMap<>();
+    }
+
+    public Set<Index> getAcceptedIndices() {
+        return acceptedIndices;
+    }
+
+    public Map<Index, String> getRejectedIndices() {
+        return rejectedIndices;
+    }
+
+    public void addToRejected(Index index, String reason) {
+        acceptedIndices.remove(index);
+        rejectedIndices.put(index, reason);
+    }
+
+    public HotToWarmTieringResponse constructResponse() {
+        final List<HotToWarmTieringResponse.IndexResult> indicesResult = new LinkedList<>();
+        for (Map.Entry<Index, String> rejectedIndex : rejectedIndices.entrySet()) {
+            indicesResult.add(new HotToWarmTieringResponse.IndexResult(rejectedIndex.getKey().getName(), rejectedIndex.getValue()));
+        }
+        return new HotToWarmTieringResponse(acceptedIndices.size() > 0, indicesResult);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        TieringValidationResult that = (TieringValidationResult) o;
+
+        if (!Objects.equals(acceptedIndices, that.acceptedIndices)) return false;
+        return Objects.equals(rejectedIndices, that.rejectedIndices);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = acceptedIndices != null ? acceptedIndices.hashCode() : 0;
+        result = 31 * result + (rejectedIndices != null ? rejectedIndices.hashCode() : 0);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "TieringValidationResult{" + "acceptedIndices=" + acceptedIndices + ", rejectedIndices=" + rejectedIndices + '}';
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/tiering/TransportHotToWarmTieringAction.java b/server/src/main/java/org/opensearch/action/admin/indices/tiering/TransportHotToWarmTieringAction.java
new file mode 100644
index 0000000000000..8d1ab0bb37cdd
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/tiering/TransportHotToWarmTieringAction.java
@@ -0,0 +1,110 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.clustermanager.TransportClusterManagerNodeAction;
+import org.opensearch.cluster.ClusterInfoService;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.block.ClusterBlockException;
+import org.opensearch.cluster.block.ClusterBlockLevel;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.routing.allocation.DiskThresholdSettings;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.index.Index;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+
+import java.io.IOException;
+import java.util.Set;
+
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateHotToWarm;
+
+/**
+ * Transport Tiering action to move indices from hot to warm
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class TransportHotToWarmTieringAction extends TransportClusterManagerNodeAction<TieringIndexRequest, HotToWarmTieringResponse> {
+
+    private static final Logger logger = LogManager.getLogger(TransportHotToWarmTieringAction.class);
+    private final ClusterInfoService clusterInfoService;
+    private final DiskThresholdSettings diskThresholdSettings;
+
+    @Inject
+    public TransportHotToWarmTieringAction(
+        TransportService transportService,
+        ClusterService clusterService,
+        ThreadPool threadPool,
+        ActionFilters actionFilters,
+        IndexNameExpressionResolver indexNameExpressionResolver,
+        ClusterInfoService clusterInfoService,
+        Settings settings
+    ) {
+        super(
+            HotToWarmTieringAction.NAME,
+            transportService,
+            clusterService,
+            threadPool,
+            actionFilters,
+            TieringIndexRequest::new,
+            indexNameExpressionResolver
+        );
+        this.clusterInfoService = clusterInfoService;
+        this.diskThresholdSettings = new DiskThresholdSettings(settings, clusterService.getClusterSettings());
+    }
+
+    @Override
+    protected String executor() {
+        return ThreadPool.Names.SAME;
+    }
+
+    @Override
+    protected HotToWarmTieringResponse read(StreamInput in) throws IOException {
+        return new HotToWarmTieringResponse(in);
+    }
+
+    @Override
+    protected ClusterBlockException checkBlock(TieringIndexRequest request, ClusterState state) {
+        return state.blocks()
+            .indicesBlockedException(ClusterBlockLevel.METADATA_WRITE, indexNameExpressionResolver.concreteIndexNames(state, request));
+    }
+
+    @Override
+    protected void clusterManagerOperation(
+        TieringIndexRequest request,
+        ClusterState state,
+        ActionListener<HotToWarmTieringResponse> listener
+    ) throws Exception {
+        Index[] concreteIndices = indexNameExpressionResolver.concreteIndices(state, request);
+        if (concreteIndices == null || concreteIndices.length == 0) {
+            listener.onResponse(new HotToWarmTieringResponse(true));
+            return;
+        }
+        final TieringValidationResult tieringValidationResult = validateHotToWarm(
+            state,
+            Set.of(concreteIndices),
+            clusterInfoService.getClusterInfo(),
+            diskThresholdSettings
+        );
+
+        if (tieringValidationResult.getAcceptedIndices().isEmpty()) {
+            listener.onResponse(tieringValidationResult.constructResponse());
+            return;
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/tiering/package-info.java b/server/src/main/java/org/opensearch/action/admin/indices/tiering/package-info.java
new file mode 100644
index 0000000000000..878e3575a3934
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/tiering/package-info.java
@@ -0,0 +1,36 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/**
+ * Actions that OpenSearch can take to tier the indices
+ */
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
diff --git a/server/src/main/java/org/opensearch/action/bulk/BulkRequest.java b/server/src/main/java/org/opensearch/action/bulk/BulkRequest.java
index 7614206cd226f..e686585095962 100644
--- a/server/src/main/java/org/opensearch/action/bulk/BulkRequest.java
+++ b/server/src/main/java/org/opensearch/action/bulk/BulkRequest.java
@@ -96,7 +96,7 @@ public class BulkRequest extends ActionRequest implements CompositeIndicesReques
     private String globalRouting;
     private String globalIndex;
     private Boolean globalRequireAlias;
-    private int batchSize = 1;
+    private int batchSize = Integer.MAX_VALUE;
 
     private long sizeInBytes = 0;
 
diff --git a/server/src/main/java/org/opensearch/action/ingest/GetPipelineTransportAction.java b/server/src/main/java/org/opensearch/action/ingest/GetPipelineTransportAction.java
index 80333c7346f92..7bc0380bccbc0 100644
--- a/server/src/main/java/org/opensearch/action/ingest/GetPipelineTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/ingest/GetPipelineTransportAction.java
@@ -70,7 +70,8 @@ public GetPipelineTransportAction(
             threadPool,
             actionFilters,
             GetPipelineRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/search/GetSearchPipelineTransportAction.java b/server/src/main/java/org/opensearch/action/search/GetSearchPipelineTransportAction.java
index a7fcb8f1cfbae..215b7ae1a610c 100644
--- a/server/src/main/java/org/opensearch/action/search/GetSearchPipelineTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/search/GetSearchPipelineTransportAction.java
@@ -48,7 +48,8 @@ public GetSearchPipelineTransportAction(
             threadPool,
             actionFilters,
             GetSearchPipelineRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/search/SearchTaskRequestOperationsListener.java b/server/src/main/java/org/opensearch/action/search/SearchTaskRequestOperationsListener.java
new file mode 100644
index 0000000000000..4434d71793b23
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/search/SearchTaskRequestOperationsListener.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.search;
+
+import org.opensearch.tasks.TaskResourceTrackingService;
+
+/**
+ * SearchTaskRequestOperationsListener subscriber for operations on search tasks resource usages.
+ * Listener ensures to refreshResourceStats on request end capturing the search task resource usage
+ * upon request completion.
+ *
+ */
+public final class SearchTaskRequestOperationsListener extends SearchRequestOperationsListener {
+    private final TaskResourceTrackingService taskResourceTrackingService;
+
+    public SearchTaskRequestOperationsListener(TaskResourceTrackingService taskResourceTrackingService) {
+        this.taskResourceTrackingService = taskResourceTrackingService;
+    }
+
+    @Override
+    public void onRequestEnd(SearchPhaseContext context, SearchRequestContext searchRequestContext) {
+        taskResourceTrackingService.refreshResourceStats(context.getTask());
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
index 080b0d607e991..4e869f29878cd 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
@@ -267,24 +267,7 @@ protected void doStart(ClusterState clusterState) {
                 final DiscoveryNodes nodes = clusterState.nodes();
                 if (nodes.isLocalNodeElectedClusterManager() || localExecute(request)) {
                     // check for block, if blocked, retry, else, execute locally
-                    final ClusterBlockException blockException = checkBlock(request, clusterState);
-                    if (blockException != null) {
-                        if (!blockException.retryable()) {
-                            listener.onFailure(blockException);
-                        } else {
-                            logger.debug("can't execute due to a cluster block, retrying", blockException);
-                            retry(clusterState, blockException, newState -> {
-                                try {
-                                    ClusterBlockException newException = checkBlock(request, newState);
-                                    return (newException == null || !newException.retryable());
-                                } catch (Exception e) {
-                                    // accept state as block will be rechecked by doStart() and listener.onFailure() then called
-                                    logger.trace("exception occurred during cluster block checking, accepting state", e);
-                                    return true;
-                                }
-                            });
-                        }
-                    } else {
+                    if (!checkForBlock(request, clusterState)) {
                         threadPool.executor(executor)
                             .execute(
                                 ActionRunnable.wrap(
@@ -422,12 +405,43 @@ public GetTermVersionResponse read(StreamInput in) throws IOException {
             };
         }
 
+        private boolean checkForBlock(Request request, ClusterState localClusterState) {
+            final ClusterBlockException blockException = checkBlock(request, localClusterState);
+            if (blockException != null) {
+                if (!blockException.retryable()) {
+                    listener.onFailure(blockException);
+                } else {
+                    logger.debug("can't execute due to a cluster block, retrying", blockException);
+                    retry(localClusterState, blockException, newState -> {
+                        try {
+                            ClusterBlockException newException = checkBlock(request, newState);
+                            return (newException == null || !newException.retryable());
+                        } catch (Exception e) {
+                            // accept state as block will be rechecked by doStart() and listener.onFailure() then called
+                            logger.trace("exception occurred during cluster block checking, accepting state", e);
+                            return true;
+                        }
+                    });
+                }
+                return true;
+            } else {
+                return false;
+            }
+        }
+
         private void executeOnLocalNode(ClusterState localClusterState) {
-            Runnable runTask = ActionRunnable.wrap(
-                getDelegateForLocalExecute(localClusterState),
-                l -> clusterManagerOperation(task, request, localClusterState, l)
-            );
-            threadPool.executor(executor).execute(runTask);
+            try {
+                // check for block, if blocked, retry, else, execute locally
+                if (!checkForBlock(request, localClusterState)) {
+                    Runnable runTask = ActionRunnable.wrap(
+                        getDelegateForLocalExecute(localClusterState),
+                        l -> clusterManagerOperation(task, request, localClusterState, l)
+                    );
+                    threadPool.executor(executor).execute(runTask);
+                }
+            } catch (Exception e) {
+                listener.onFailure(e);
+            }
         }
 
         private void executeOnClusterManager(DiscoveryNode clusterManagerNode, ClusterState clusterState) {
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeReadAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeReadAction.java
index d58487a475bcf..88cb2ed6a9bf0 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeReadAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeReadAction.java
@@ -51,6 +51,8 @@ public abstract class TransportClusterManagerNodeReadAction<
     Request extends ClusterManagerNodeReadRequest<Request>,
     Response extends ActionResponse> extends TransportClusterManagerNodeAction<Request, Response> {
 
+    protected boolean localExecuteSupported = false;
+
     protected TransportClusterManagerNodeReadAction(
         String actionName,
         TransportService transportService,
@@ -58,7 +60,8 @@ protected TransportClusterManagerNodeReadAction(
         ThreadPool threadPool,
         ActionFilters actionFilters,
         Writeable.Reader<Request> request,
-        IndexNameExpressionResolver indexNameExpressionResolver
+        IndexNameExpressionResolver indexNameExpressionResolver,
+        boolean localExecuteSupported
     ) {
         this(
             actionName,
@@ -71,6 +74,19 @@ protected TransportClusterManagerNodeReadAction(
             request,
             indexNameExpressionResolver
         );
+        this.localExecuteSupported = localExecuteSupported;
+    }
+
+    protected TransportClusterManagerNodeReadAction(
+        String actionName,
+        TransportService transportService,
+        ClusterService clusterService,
+        ThreadPool threadPool,
+        ActionFilters actionFilters,
+        Writeable.Reader<Request> request,
+        IndexNameExpressionResolver indexNameExpressionResolver
+    ) {
+        this(actionName, transportService, clusterService, threadPool, actionFilters, request, indexNameExpressionResolver, false);
     }
 
     protected TransportClusterManagerNodeReadAction(
@@ -124,4 +140,9 @@ protected TransportClusterManagerNodeReadAction(
     protected final boolean localExecute(Request request) {
         return request.local();
     }
+
+    protected boolean localExecuteSupportedByAction() {
+        return localExecuteSupported;
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/info/TransportClusterInfoAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/info/TransportClusterInfoAction.java
index 65f00a4731ab5..8a0082ad05f66 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/info/TransportClusterInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/info/TransportClusterInfoAction.java
@@ -62,6 +62,7 @@ public TransportClusterInfoAction(
         IndexNameExpressionResolver indexNameExpressionResolver
     ) {
         super(actionName, transportService, clusterService, threadPool, actionFilters, request, indexNameExpressionResolver);
+        this.localExecuteSupported = true;
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/BaseNodesRequest.java b/server/src/main/java/org/opensearch/action/support/nodes/BaseNodesRequest.java
index 4d54ce51c923c..a4f6d8afeaf38 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/BaseNodesRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/BaseNodesRequest.java
@@ -65,6 +65,14 @@ public abstract class BaseNodesRequest<Request extends BaseNodesRequest<Request>
      * will be ignored and this will be used.
      * */
     private DiscoveryNode[] concreteNodes;
+
+    /**
+     * Since do not use the discovery nodes coming from the request in all code paths following a request extended off from
+     * BaseNodeRequest, we do not require it to sent around across all nodes.
+     *
+     * Setting default behavior as `true` but can be explicitly changed in requests that do not require.
+     */
+    private boolean includeDiscoveryNodes = true;
     private final TimeValue DEFAULT_TIMEOUT_SECS = TimeValue.timeValueSeconds(30);
 
     private TimeValue timeout;
@@ -119,6 +127,14 @@ public void setConcreteNodes(DiscoveryNode[] concreteNodes) {
         this.concreteNodes = concreteNodes;
     }
 
+    public void setIncludeDiscoveryNodes(boolean value) {
+        includeDiscoveryNodes = value;
+    }
+
+    public boolean getIncludeDiscoveryNodes() {
+        return includeDiscoveryNodes;
+    }
+
     @Override
     public ActionRequestValidationException validate() {
         return null;
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
index 9a1a28dd70636..3acd12f632e0f 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
@@ -226,6 +226,7 @@ class AsyncAction {
         private final NodesRequest request;
         private final ActionListener<NodesResponse> listener;
         private final AtomicReferenceArray<Object> responses;
+        private final DiscoveryNode[] concreteNodes;
         private final AtomicInteger counter = new AtomicInteger();
         private final Task task;
 
@@ -238,10 +239,18 @@ class AsyncAction {
                 assert request.concreteNodes() != null;
             }
             this.responses = new AtomicReferenceArray<>(request.concreteNodes().length);
+            this.concreteNodes = request.concreteNodes();
+
+            if (request.getIncludeDiscoveryNodes() == false) {
+                // As we transfer the ownership of discovery nodes to route the request to into the AsyncAction class, we
+                // remove the list of DiscoveryNodes from the request. This reduces the payload of the request and improves
+                // the number of concrete nodes in the memory.
+                request.setConcreteNodes(null);
+            }
         }
 
         void start() {
-            final DiscoveryNode[] nodes = request.concreteNodes();
+            final DiscoveryNode[] nodes = this.concreteNodes;
             if (nodes.length == 0) {
                 // nothing to notify
                 threadPool.generic().execute(() -> listener.onResponse(newResponse(request, responses)));
@@ -260,7 +269,6 @@ void start() {
                     if (task != null) {
                         nodeRequest.setParentTask(clusterService.localNode().getId(), task.getId());
                     }
-
                     transportService.sendRequest(
                         node,
                         getTransportNodeAction(node),
diff --git a/server/src/main/java/org/opensearch/action/update/UpdateRequest.java b/server/src/main/java/org/opensearch/action/update/UpdateRequest.java
index 9654bd1c114ba..6cb5e049e0f1e 100644
--- a/server/src/main/java/org/opensearch/action/update/UpdateRequest.java
+++ b/server/src/main/java/org/opensearch/action/update/UpdateRequest.java
@@ -717,7 +717,7 @@ public IndexRequest doc() {
 
     private IndexRequest safeDoc() {
         if (doc == null) {
-            doc = new IndexRequest();
+            doc = new IndexRequest(index);
         }
         return doc;
     }
@@ -803,7 +803,7 @@ public IndexRequest upsertRequest() {
 
     private IndexRequest safeUpsertRequest() {
         if (upsertRequest == null) {
-            upsertRequest = new IndexRequest();
+            upsertRequest = new IndexRequest(index);
         }
         return upsertRequest;
     }
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterInfo.java b/server/src/main/java/org/opensearch/cluster/ClusterInfo.java
index 4c38d6fd99f5d..7216c447acc3e 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterInfo.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterInfo.java
@@ -33,6 +33,7 @@
 package org.opensearch.cluster;
 
 import org.opensearch.Version;
+import org.opensearch.cluster.routing.RoutingNode;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.core.common.io.stream.StreamInput;
@@ -68,6 +69,8 @@ public class ClusterInfo implements ToXContentFragment, Writeable {
     final Map<ShardRouting, String> routingToDataPath;
     final Map<NodeAndPath, ReservedSpace> reservedSpace;
     final Map<String, FileCacheStats> nodeFileCacheStats;
+    private long avgTotalBytes;
+    private long avgFreeByte;
 
     protected ClusterInfo() {
         this(Map.of(), Map.of(), Map.of(), Map.of(), Map.of(), Map.of());
@@ -97,6 +100,7 @@ public ClusterInfo(
         this.routingToDataPath = routingToDataPath;
         this.reservedSpace = reservedSpace;
         this.nodeFileCacheStats = nodeFileCacheStats;
+        calculateAvgFreeAndTotalBytes(mostAvailableSpaceUsage);
     }
 
     public ClusterInfo(StreamInput in) throws IOException {
@@ -117,6 +121,39 @@ public ClusterInfo(StreamInput in) throws IOException {
         } else {
             this.nodeFileCacheStats = Map.of();
         }
+
+        calculateAvgFreeAndTotalBytes(mostAvailableSpaceUsage);
+    }
+
+    /**
+     * Returns a {@link DiskUsage} for the {@link RoutingNode} using the
+     * average usage of other nodes in the disk usage map.
+     * @param usages Map of nodeId to DiskUsage for all known nodes
+     */
+    private void calculateAvgFreeAndTotalBytes(final Map<String, DiskUsage> usages) {
+        if (usages == null || usages.isEmpty()) {
+            this.avgTotalBytes = 0;
+            this.avgFreeByte = 0;
+            return;
+        }
+
+        long totalBytes = 0;
+        long freeBytes = 0;
+        for (DiskUsage du : usages.values()) {
+            totalBytes += du.getTotalBytes();
+            freeBytes += du.getFreeBytes();
+        }
+
+        this.avgTotalBytes = totalBytes / usages.size();
+        this.avgFreeByte = freeBytes / usages.size();
+    }
+
+    public long getAvgFreeByte() {
+        return avgFreeByte;
+    }
+
+    public long getAvgTotalBytes() {
+        return avgTotalBytes;
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/ClusterStateSystemTemplateLoader.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/ClusterStateSystemTemplateLoader.java
new file mode 100644
index 0000000000000..332960ef49064
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/ClusterStateSystemTemplateLoader.java
@@ -0,0 +1,108 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.OpenSearchCorruptionException;
+import org.opensearch.action.admin.indices.template.put.PutComponentTemplateAction;
+import org.opensearch.client.Client;
+import org.opensearch.client.OriginSettingClient;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.ComponentTemplate;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.xcontent.DeprecationHandler;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.core.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.util.Objects;
+import java.util.function.Supplier;
+
+/**
+ * Class responsible for loading the component templates provided by a repository into the cluster state.
+ */
+@ExperimentalApi
+public class ClusterStateSystemTemplateLoader implements SystemTemplateLoader {
+
+    private final Client client;
+
+    private final Supplier<ClusterState> clusterStateSupplier;
+
+    private static final Logger logger = LogManager.getLogger(SystemTemplateLoader.class);
+
+    public static final String TEMPLATE_LOADER_IDENTIFIER = "system_template_loader";
+    public static final String TEMPLATE_TYPE_KEY = "_type";
+
+    public ClusterStateSystemTemplateLoader(Client client, Supplier<ClusterState> clusterStateSupplier) {
+        this.client = new OriginSettingClient(client, TEMPLATE_LOADER_IDENTIFIER);
+        this.clusterStateSupplier = clusterStateSupplier;
+    }
+
+    @Override
+    public boolean loadTemplate(SystemTemplate template) throws IOException {
+        final ComponentTemplate existingTemplate = clusterStateSupplier.get()
+            .metadata()
+            .componentTemplates()
+            .get(template.templateMetadata().fullyQualifiedName());
+
+        if (existingTemplate != null
+            && !SystemTemplateMetadata.COMPONENT_TEMPLATE_TYPE.equals(
+                Objects.toString(existingTemplate.metadata().get(TEMPLATE_TYPE_KEY))
+            )) {
+            throw new OpenSearchCorruptionException(
+                "Attempting to create " + template.templateMetadata().name() + " which has already been created through some other source."
+            );
+        }
+
+        if (existingTemplate != null && existingTemplate.version() >= template.templateMetadata().version()) {
+            logger.debug(
+                "Skipping putting template {} as its existing version [{}] is >= fetched version [{}]",
+                template.templateMetadata().fullyQualifiedName(),
+                existingTemplate.version(),
+                template.templateMetadata().version()
+            );
+            return false;
+        }
+
+        ComponentTemplate newTemplate = null;
+        try (
+            XContentParser contentParser = JsonXContent.jsonXContent.createParser(
+                NamedXContentRegistry.EMPTY,
+                DeprecationHandler.IGNORE_DEPRECATIONS,
+                template.templateContent().utf8ToString()
+            )
+        ) {
+            newTemplate = ComponentTemplate.parse(contentParser);
+        }
+
+        if (!Objects.equals(newTemplate.version(), template.templateMetadata().version())) {
+            throw new OpenSearchCorruptionException(
+                "Template version mismatch for "
+                    + template.templateMetadata().name()
+                    + ". Version in metadata: "
+                    + template.templateMetadata().version()
+                    + " , Version in content: "
+                    + newTemplate.version()
+            );
+        }
+
+        final PutComponentTemplateAction.Request request = new PutComponentTemplateAction.Request(
+            template.templateMetadata().fullyQualifiedName()
+        ).componentTemplate(newTemplate);
+
+        return client.admin()
+            .indices()
+            .execute(PutComponentTemplateAction.INSTANCE, request)
+            .actionGet(TimeValue.timeValueMillis(30000))
+            .isAcknowledged();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplate.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplate.java
new file mode 100644
index 0000000000000..e11ded7ef5546
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplate.java
@@ -0,0 +1,43 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.common.bytes.BytesReference;
+
+/**
+ * Encapsulates the information and content about a system template available within a repository.
+ */
+@ExperimentalApi
+public class SystemTemplate {
+
+    private final BytesReference templateContent;
+
+    private final SystemTemplateMetadata templateMetadata;
+
+    private final TemplateRepositoryMetadata repositoryMetadata;
+
+    public SystemTemplate(BytesReference templateContent, SystemTemplateMetadata templateInfo, TemplateRepositoryMetadata repositoryInfo) {
+        this.templateContent = templateContent;
+        this.templateMetadata = templateInfo;
+        this.repositoryMetadata = repositoryInfo;
+    }
+
+    public BytesReference templateContent() {
+        return templateContent;
+    }
+
+    public SystemTemplateMetadata templateMetadata() {
+        return templateMetadata;
+    }
+
+    public TemplateRepositoryMetadata repositoryMetadata() {
+        return repositoryMetadata;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateLoader.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateLoader.java
new file mode 100644
index 0000000000000..077580aed5a64
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateLoader.java
@@ -0,0 +1,26 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.io.IOException;
+
+/**
+ * Interface to load template into the OpenSearch runtime.
+ */
+@ExperimentalApi
+public interface SystemTemplateLoader {
+
+    /**
+     * @param template Templated to be loaded
+     * @throws IOException If an exceptional situation is encountered while parsing/loading the template
+     */
+    boolean loadTemplate(SystemTemplate template) throws IOException;
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateMetadata.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateMetadata.java
new file mode 100644
index 0000000000000..9bbe27ac0e281
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateMetadata.java
@@ -0,0 +1,68 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+/**
+ * Metadata information about a template available in a template repository.
+ */
+@ExperimentalApi
+public class SystemTemplateMetadata {
+
+    private final long version;
+    private final String type;
+    private final String name;
+
+    private static final String DELIMITER = "@";
+
+    public static final String COMPONENT_TEMPLATE_TYPE = "@abc_template";
+
+    public SystemTemplateMetadata(long version, String type, String name) {
+        this.version = version;
+        this.type = type;
+        this.name = name;
+    }
+
+    public String type() {
+        return type;
+    }
+
+    public String name() {
+        return name;
+    }
+
+    public long version() {
+        return version;
+    }
+
+    /**
+     * Gets the metadata using fully qualified name for the template
+     * @param fullyQualifiedName (e.g. @abc_template@logs@1)
+     * @return Metadata object based on name
+     */
+    public static SystemTemplateMetadata fromComponentTemplate(String fullyQualifiedName) {
+        assert fullyQualifiedName.length() > 1 : "System template name must have at least one component";
+        assert fullyQualifiedName.substring(1, fullyQualifiedName.indexOf(DELIMITER, 1)).equals(COMPONENT_TEMPLATE_TYPE);
+
+        return new SystemTemplateMetadata(
+            Long.parseLong(fullyQualifiedName.substring(fullyQualifiedName.lastIndexOf(DELIMITER))),
+            COMPONENT_TEMPLATE_TYPE,
+            fullyQualifiedName.substring(0, fullyQualifiedName.lastIndexOf(DELIMITER))
+        );
+    }
+
+    public static SystemTemplateMetadata fromComponentTemplateInfo(String name, long version) {
+        return new SystemTemplateMetadata(version, COMPONENT_TEMPLATE_TYPE, name);
+    }
+
+    public final String fullyQualifiedName() {
+        return type + DELIMITER + name + DELIMITER + version;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateRepository.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateRepository.java
new file mode 100644
index 0000000000000..9cf302b8874f2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateRepository.java
@@ -0,0 +1,37 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.io.IOException;
+
+/**
+ * Repository interface around the templates provided by a store (e.g. code repo, remote file store, etc)
+ */
+@ExperimentalApi
+public interface SystemTemplateRepository extends AutoCloseable {
+
+    /**
+     * @return Metadata about the repository
+     */
+    TemplateRepositoryMetadata metadata();
+
+    /**
+     * @return Metadata for all available templates
+     */
+    Iterable<SystemTemplateMetadata> listTemplates() throws IOException;
+
+    /**
+     *
+     * @param template metadata about template to be fetched
+     * @return The actual template content
+     */
+    SystemTemplate getTemplate(SystemTemplateMetadata template) throws IOException;
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesPlugin.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesPlugin.java
new file mode 100644
index 0000000000000..54871e6db7010
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesPlugin.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.io.IOException;
+
+/**
+ * Plugin interface to expose the template maintaining logic.
+ */
+@ExperimentalApi
+public interface SystemTemplatesPlugin {
+
+    /**
+     * @return repository implementation from which templates are to be fetched.
+     */
+    SystemTemplateRepository loadRepository() throws IOException;
+
+    /**
+     * @param templateInfo Metadata about the template to load
+     * @return Implementation of TemplateLoader which determines how to make the template available at runtime.
+     */
+    SystemTemplateLoader loaderFor(SystemTemplateMetadata templateInfo);
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesService.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesService.java
new file mode 100644
index 0000000000000..ccb9272fa57b1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesService.java
@@ -0,0 +1,183 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.cluster.LocalNodeClusterManagerListener;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Service class to orchestrate execution around available templates' management.
+ */
+@ExperimentalApi
+public class SystemTemplatesService implements LocalNodeClusterManagerListener {
+
+    public static final Setting<Boolean> SETTING_APPLICATION_BASED_CONFIGURATION_TEMPLATES_ENABLED = Setting.boolSetting(
+        "cluster.application_templates.enabled",
+        false,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+
+    private final List<SystemTemplatesPlugin> systemTemplatesPluginList;
+    private final ThreadPool threadPool;
+
+    private final AtomicBoolean loaded = new AtomicBoolean(false);
+
+    private volatile boolean enabledTemplates;
+
+    private volatile Stats latestStats;
+
+    private static final Logger logger = LogManager.getLogger(SystemTemplatesService.class);
+
+    public SystemTemplatesService(
+        List<SystemTemplatesPlugin> systemTemplatesPluginList,
+        ThreadPool threadPool,
+        ClusterSettings clusterSettings,
+        Settings settings
+    ) {
+        this.systemTemplatesPluginList = systemTemplatesPluginList;
+        this.threadPool = threadPool;
+        if (settings.getAsBoolean(SETTING_APPLICATION_BASED_CONFIGURATION_TEMPLATES_ENABLED.getKey(), false)) {
+            setEnabledTemplates(settings.getAsBoolean(SETTING_APPLICATION_BASED_CONFIGURATION_TEMPLATES_ENABLED.getKey(), false));
+        }
+        clusterSettings.addSettingsUpdateConsumer(SETTING_APPLICATION_BASED_CONFIGURATION_TEMPLATES_ENABLED, this::setEnabledTemplates);
+    }
+
+    @Override
+    public void onClusterManager() {
+        threadPool.generic().execute(() -> refreshTemplates(false));
+    }
+
+    @Override
+    public void offClusterManager() {
+        // do nothing
+    }
+
+    public void verifyRepositories() {
+        refreshTemplates(true);
+    }
+
+    public Stats stats() {
+        return latestStats;
+    }
+
+    void refreshTemplates(boolean verification) {
+        int templatesLoaded = 0;
+        int failedLoadingTemplates = 0;
+        int failedLoadingRepositories = 0;
+        List<Exception> exceptions = new ArrayList<>();
+
+        if (loaded.compareAndSet(false, true) && enabledTemplates) {
+            for (SystemTemplatesPlugin plugin : systemTemplatesPluginList) {
+                try (SystemTemplateRepository repository = plugin.loadRepository()) {
+
+                    final TemplateRepositoryMetadata repositoryMetadata = repository.metadata();
+                    logger.debug(
+                        "Loading templates from repository: {} at version {}",
+                        repositoryMetadata.id(),
+                        repositoryMetadata.version()
+                    );
+
+                    for (SystemTemplateMetadata templateMetadata : repository.listTemplates()) {
+                        try {
+                            final SystemTemplate template = repository.getTemplate(templateMetadata);
+
+                            // Load plugin if not in verification phase.
+                            if (!verification && plugin.loaderFor(templateMetadata).loadTemplate(template)) {
+                                templatesLoaded++;
+                            }
+
+                        } catch (Exception ex) {
+                            exceptions.add(ex);
+                            logger.error(
+                                new ParameterizedMessage(
+                                    "Failed loading template  {} from repository: {}",
+                                    templateMetadata.fullyQualifiedName(),
+                                    repositoryMetadata.id()
+                                ),
+                                ex
+                            );
+                            failedLoadingTemplates++;
+                        }
+                    }
+                } catch (Exception ex) {
+                    exceptions.add(ex);
+                    failedLoadingRepositories++;
+                    logger.error(new ParameterizedMessage("Failed loading repository from plugin: {}", plugin.getClass().getName()), ex);
+                }
+            }
+
+            logger.debug(
+                "Stats: Total Loaded Templates: [{}], Failed Loading Templates: [{}], Failed Loading Repositories: [{}]",
+                templatesLoaded,
+                failedLoadingTemplates,
+                failedLoadingRepositories
+            );
+
+            // End exceptionally if invoked in verification context
+            if (verification && (failedLoadingRepositories > 0 || failedLoadingTemplates > 0)) {
+                latestStats = new Stats(templatesLoaded, failedLoadingTemplates, failedLoadingRepositories);
+                throw new IllegalStateException("Some of the repositories could not be loaded or are corrupted: " + exceptions);
+            }
+        }
+
+        latestStats = new Stats(templatesLoaded, failedLoadingTemplates, failedLoadingRepositories);
+    }
+
+    private void setEnabledTemplates(boolean enabled) {
+        if (!FeatureFlags.isEnabled(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES_SETTING)) {
+            throw new IllegalArgumentException(
+                "Application Based Configuration Templates is under an experimental feature and can be activated only by enabling "
+                    + FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES_SETTING.getKey()
+                    + " feature flag."
+            );
+        }
+        enabledTemplates = enabled;
+    }
+
+    /**
+     * Class to record stats for templates loaded through the listener in a single iteration.
+     */
+    @ExperimentalApi
+    public static class Stats {
+        private final long templatesLoaded;
+        private final long failedLoadingTemplates;
+        private final long failedLoadingRepositories;
+
+        public Stats(long templatesLoaded, long failedLoadingTemplates, long failedLoadingRepositories) {
+            this.templatesLoaded = templatesLoaded;
+            this.failedLoadingTemplates = failedLoadingTemplates;
+            this.failedLoadingRepositories = failedLoadingRepositories;
+        }
+
+        public long getTemplatesLoaded() {
+            return templatesLoaded;
+        }
+
+        public long getFailedLoadingTemplates() {
+            return failedLoadingTemplates;
+        }
+
+        public long getFailedLoadingRepositories() {
+            return failedLoadingRepositories;
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/TemplateRepositoryMetadata.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/TemplateRepositoryMetadata.java
new file mode 100644
index 0000000000000..7ab4553aade0e
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/TemplateRepositoryMetadata.java
@@ -0,0 +1,34 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+/**
+ * The information to uniquely identify a template repository.
+ */
+@ExperimentalApi
+public class TemplateRepositoryMetadata {
+
+    private final String id;
+    private final long version;
+
+    public TemplateRepositoryMetadata(String id, long version) {
+        this.id = id;
+        this.version = version;
+    }
+
+    public String id() {
+        return id;
+    }
+
+    public long version() {
+        return version;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/package-info.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/package-info.java
new file mode 100644
index 0000000000000..3fef2aab07d43
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/package-info.java
@@ -0,0 +1,10 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/** Core classes responsible for handling all application based configuration templates related operations. */
+package org.opensearch.cluster.applicationtemplates;
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PersistedStateStats.java b/server/src/main/java/org/opensearch/cluster/coordination/PersistedStateStats.java
index 0b7ed4fee5775..023c2db1a574a 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PersistedStateStats.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PersistedStateStats.java
@@ -117,6 +117,10 @@ protected void addToExtendedFields(String extendedField, AtomicLong extendedFiel
         this.extendedFields.put(extendedField, extendedFieldValue);
     }
 
+    public Map<String, AtomicLong> getExtendedFields() {
+        return extendedFields;
+    }
+
     public String getStatsName() {
         return statsName;
     }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/MetadataCreateIndexService.java b/server/src/main/java/org/opensearch/cluster/metadata/MetadataCreateIndexService.java
index 7973745ce84b3..50d25b11ef810 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/MetadataCreateIndexService.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/MetadataCreateIndexService.java
@@ -946,7 +946,8 @@ static Settings aggregateIndexSettings(
         if (INDEX_NUMBER_OF_SHARDS_SETTING.exists(indexSettingsBuilder) == false) {
             indexSettingsBuilder.put(SETTING_NUMBER_OF_SHARDS, INDEX_NUMBER_OF_SHARDS_SETTING.get(settings));
         }
-        if (INDEX_NUMBER_OF_REPLICAS_SETTING.exists(indexSettingsBuilder) == false) {
+        if (INDEX_NUMBER_OF_REPLICAS_SETTING.exists(indexSettingsBuilder) == false
+            || indexSettingsBuilder.get(SETTING_NUMBER_OF_REPLICAS) == null) {
             indexSettingsBuilder.put(SETTING_NUMBER_OF_REPLICAS, DEFAULT_REPLICA_COUNT_SETTING.get(currentState.metadata().settings()));
         }
         if (settings.get(SETTING_AUTO_EXPAND_REPLICAS) != null && indexSettingsBuilder.get(SETTING_AUTO_EXPAND_REPLICAS) == null) {
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingTableIncrementalDiff.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingTableIncrementalDiff.java
new file mode 100644
index 0000000000000..3d75b22a8ed7f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingTableIncrementalDiff.java
@@ -0,0 +1,168 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing;
+
+import org.opensearch.cluster.Diff;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Represents a difference between {@link RoutingTable} objects that can be serialized and deserialized.
+ */
+public class RoutingTableIncrementalDiff implements Diff<RoutingTable> {
+
+    private final Map<String, Diff<IndexRoutingTable>> diffs;
+
+    /**
+     * Constructs a new RoutingTableIncrementalDiff with the given differences.
+     *
+     * @param diffs a map containing the differences of {@link IndexRoutingTable}.
+     */
+    public RoutingTableIncrementalDiff(Map<String, Diff<IndexRoutingTable>> diffs) {
+        this.diffs = diffs;
+    }
+
+    /**
+     * Gets the map of differences of {@link IndexRoutingTable}.
+     *
+     * @return a map containing the differences.
+     */
+    public Map<String, Diff<IndexRoutingTable>> getDiffs() {
+        return diffs;
+    }
+
+    /**
+     * Reads a {@link RoutingTableIncrementalDiff} from the given {@link StreamInput}.
+     *
+     * @param in the input stream to read from.
+     * @return the deserialized RoutingTableIncrementalDiff.
+     * @throws IOException if an I/O exception occurs while reading from the stream.
+     */
+    public static RoutingTableIncrementalDiff readFrom(StreamInput in) throws IOException {
+        int size = in.readVInt();
+        Map<String, Diff<IndexRoutingTable>> diffs = new HashMap<>();
+
+        for (int i = 0; i < size; i++) {
+            String key = in.readString();
+            Diff<IndexRoutingTable> diff = IndexRoutingTableIncrementalDiff.readFrom(in);
+            diffs.put(key, diff);
+        }
+        return new RoutingTableIncrementalDiff(diffs);
+    }
+
+    /**
+     * Applies the differences to the provided {@link RoutingTable}.
+     *
+     * @param part the original RoutingTable to which the differences will be applied.
+     * @return the updated RoutingTable with the applied differences.
+     */
+    @Override
+    public RoutingTable apply(RoutingTable part) {
+        RoutingTable.Builder builder = new RoutingTable.Builder();
+        for (IndexRoutingTable indexRoutingTable : part) {
+            builder.add(indexRoutingTable); // Add existing index routing tables to builder
+        }
+
+        // Apply the diffs
+        for (Map.Entry<String, Diff<IndexRoutingTable>> entry : diffs.entrySet()) {
+            builder.add(entry.getValue().apply(part.index(entry.getKey())));
+        }
+
+        return builder.build();
+    }
+
+    /**
+     * Writes the differences to the given {@link StreamOutput}.
+     *
+     * @param out the output stream to write to.
+     * @throws IOException if an I/O exception occurs while writing to the stream.
+     */
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeVInt(diffs.size());
+        for (Map.Entry<String, Diff<IndexRoutingTable>> entry : diffs.entrySet()) {
+            out.writeString(entry.getKey());
+            entry.getValue().writeTo(out);
+        }
+    }
+
+    /**
+     * Represents a difference between {@link IndexShardRoutingTable} objects that can be serialized and deserialized.
+     */
+    public static class IndexRoutingTableIncrementalDiff implements Diff<IndexRoutingTable> {
+
+        private final List<IndexShardRoutingTable> indexShardRoutingTables;
+
+        /**
+         * Constructs a new IndexShardRoutingTableDiff with the given shard routing tables.
+         *
+         * @param indexShardRoutingTables a list of IndexShardRoutingTable representing the differences.
+         */
+        public IndexRoutingTableIncrementalDiff(List<IndexShardRoutingTable> indexShardRoutingTables) {
+            this.indexShardRoutingTables = indexShardRoutingTables;
+        }
+
+        /**
+         * Applies the differences to the provided {@link IndexRoutingTable}.
+         *
+         * @param part the original IndexRoutingTable to which the differences will be applied.
+         * @return the updated IndexRoutingTable with the applied differences.
+         */
+        @Override
+        public IndexRoutingTable apply(IndexRoutingTable part) {
+            IndexRoutingTable.Builder builder = new IndexRoutingTable.Builder(part.getIndex());
+            for (IndexShardRoutingTable shardRoutingTable : part) {
+                builder.addIndexShard(shardRoutingTable); // Add existing shards to builder
+            }
+
+            // Apply the diff: update or add the new shard routing tables
+            for (IndexShardRoutingTable diffShard : indexShardRoutingTables) {
+                builder.addIndexShard(diffShard);
+            }
+            return builder.build();
+        }
+
+        /**
+         * Writes the differences to the given {@link StreamOutput}.
+         *
+         * @param out the output stream to write to.
+         * @throws IOException if an I/O exception occurs while writing to the stream.
+         */
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            out.writeVInt(indexShardRoutingTables.size());
+            for (IndexShardRoutingTable shardRoutingTable : indexShardRoutingTables) {
+                IndexShardRoutingTable.Builder.writeTo(shardRoutingTable, out);
+            }
+        }
+
+        /**
+         * Reads a {@link IndexRoutingTableIncrementalDiff} from the given {@link StreamInput}.
+         *
+         * @param in the input stream to read from.
+         * @return the deserialized IndexShardRoutingTableDiff.
+         * @throws IOException if an I/O exception occurs while reading from the stream.
+         */
+        public static IndexRoutingTableIncrementalDiff readFrom(StreamInput in) throws IOException {
+            int size = in.readVInt();
+            List<IndexShardRoutingTable> indexShardRoutingTables = new ArrayList<>(size);
+            for (int i = 0; i < size; i++) {
+                IndexShardRoutingTable shardRoutingTable = IndexShardRoutingTable.Builder.readFrom(in);
+                indexShardRoutingTables.add(shardRoutingTable);
+            }
+            return new IndexRoutingTableIncrementalDiff(indexShardRoutingTables);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/ConstraintTypes.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/ConstraintTypes.java
index 08fe8f92d1f80..28ad199218884 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/ConstraintTypes.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/ConstraintTypes.java
@@ -70,7 +70,7 @@ public static Predicate<Constraint.ConstraintParams> isPerIndexPrimaryShardsPerN
         return (params) -> {
             int perIndexPrimaryShardCount = params.getNode().numPrimaryShards(params.getIndex());
             int perIndexAllowedPrimaryShardCount = (int) Math.ceil(params.getBalancer().avgPrimaryShardsPerNode(params.getIndex()));
-            return perIndexPrimaryShardCount > perIndexAllowedPrimaryShardCount;
+            return perIndexPrimaryShardCount >= perIndexAllowedPrimaryShardCount;
         };
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/AwarenessAllocationDecider.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/AwarenessAllocationDecider.java
index 5344d95b217a7..16c94acfbb553 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/AwarenessAllocationDecider.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/AwarenessAllocationDecider.java
@@ -111,7 +111,6 @@ public class AwarenessAllocationDecider extends AllocationDecider {
     );
 
     private volatile List<String> awarenessAttributes;
-
     private volatile Map<String, List<String>> forcedAwarenessAttributes;
 
     public AwarenessAllocationDecider(Settings settings, ClusterSettings clusterSettings) {
@@ -163,8 +162,8 @@ private Decision underCapacity(ShardRouting shardRouting, RoutingNode node, Rout
         IndexMetadata indexMetadata = allocation.metadata().getIndexSafe(shardRouting.index());
         int shardCount = indexMetadata.getNumberOfReplicas() + 1; // 1 for primary
         for (String awarenessAttribute : awarenessAttributes) {
-            // the node the shard exists on must be associated with an awareness attribute
-            if (node.node().getAttributes().containsKey(awarenessAttribute) == false) {
+            // the node the shard exists on must be associated with an awareness attribute.
+            if (isAwarenessAttributeAssociatedWithNode(node, awarenessAttribute) == false) {
                 return allocation.decision(
                     Decision.NO,
                     NAME,
@@ -175,36 +174,10 @@ private Decision underCapacity(ShardRouting shardRouting, RoutingNode node, Rout
                 );
             }
 
+            int currentNodeCount = getCurrentNodeCountForAttribute(shardRouting, node, allocation, moveToNode, awarenessAttribute);
+
             // build attr_value -> nodes map
             Set<String> nodesPerAttribute = allocation.routingNodes().nodesPerAttributesCounts(awarenessAttribute);
-
-            // build the count of shards per attribute value
-            Map<String, Integer> shardPerAttribute = new HashMap<>();
-            for (ShardRouting assignedShard : allocation.routingNodes().assignedShards(shardRouting.shardId())) {
-                if (assignedShard.started() || assignedShard.initializing()) {
-                    // Note: this also counts relocation targets as that will be the new location of the shard.
-                    // Relocation sources should not be counted as the shard is moving away
-                    RoutingNode routingNode = allocation.routingNodes().node(assignedShard.currentNodeId());
-                    shardPerAttribute.merge(routingNode.node().getAttributes().get(awarenessAttribute), 1, Integer::sum);
-                }
-            }
-
-            if (moveToNode) {
-                if (shardRouting.assignedToNode()) {
-                    String nodeId = shardRouting.relocating() ? shardRouting.relocatingNodeId() : shardRouting.currentNodeId();
-                    if (node.nodeId().equals(nodeId) == false) {
-                        // we work on different nodes, move counts around
-                        shardPerAttribute.compute(
-                            allocation.routingNodes().node(nodeId).node().getAttributes().get(awarenessAttribute),
-                            (k, v) -> (v == null) ? 0 : v - 1
-                        );
-                        shardPerAttribute.merge(node.node().getAttributes().get(awarenessAttribute), 1, Integer::sum);
-                    }
-                } else {
-                    shardPerAttribute.merge(node.node().getAttributes().get(awarenessAttribute), 1, Integer::sum);
-                }
-            }
-
             int numberOfAttributes = nodesPerAttribute.size();
             List<String> fullValues = forcedAwarenessAttributes.get(awarenessAttribute);
 
@@ -216,9 +189,8 @@ private Decision underCapacity(ShardRouting shardRouting, RoutingNode node, Rout
                 }
                 numberOfAttributes = attributesSet.size();
             }
-            // TODO should we remove ones that are not part of full list?
 
-            final int currentNodeCount = shardPerAttribute.get(node.node().getAttributes().get(awarenessAttribute));
+            // TODO should we remove ones that are not part of full list?
             final int maximumNodeCount = (shardCount + numberOfAttributes - 1) / numberOfAttributes; // ceil(shardCount/numberOfAttributes)
             if (currentNodeCount > maximumNodeCount) {
                 return allocation.decision(
@@ -238,4 +210,57 @@ private Decision underCapacity(ShardRouting shardRouting, RoutingNode node, Rout
 
         return allocation.decision(Decision.YES, NAME, "node meets all awareness attribute requirements");
     }
+
+    private int getCurrentNodeCountForAttribute(
+        ShardRouting shardRouting,
+        RoutingNode node,
+        RoutingAllocation allocation,
+        boolean moveToNode,
+        String awarenessAttribute
+    ) {
+        // build the count of shards per attribute value
+        final String shardAttributeForNode = getAttributeValueForNode(node, awarenessAttribute);
+        int currentNodeCount = 0;
+        final List<ShardRouting> assignedShards = allocation.routingNodes().assignedShards(shardRouting.shardId());
+
+        for (ShardRouting assignedShard : assignedShards) {
+            if (assignedShard.started() || assignedShard.initializing()) {
+                // Note: this also counts relocation targets as that will be the new location of the shard.
+                // Relocation sources should not be counted as the shard is moving away
+                RoutingNode routingNode = allocation.routingNodes().node(assignedShard.currentNodeId());
+                // Increase node count when
+                if (getAttributeValueForNode(routingNode, awarenessAttribute).equals(shardAttributeForNode)) {
+                    ++currentNodeCount;
+                }
+            }
+        }
+
+        if (moveToNode) {
+            if (shardRouting.assignedToNode()) {
+                String nodeId = shardRouting.relocating() ? shardRouting.relocatingNodeId() : shardRouting.currentNodeId();
+                if (node.nodeId().equals(nodeId) == false) {
+                    // we work on different nodes, move counts around
+                    if (getAttributeValueForNode(allocation.routingNodes().node(nodeId), awarenessAttribute).equals(shardAttributeForNode)
+                        && currentNodeCount > 0) {
+                        --currentNodeCount;
+                    }
+
+                    ++currentNodeCount;
+                }
+            } else {
+                ++currentNodeCount;
+            }
+        }
+
+        return currentNodeCount;
+    }
+
+    private boolean isAwarenessAttributeAssociatedWithNode(RoutingNode node, String awarenessAttribute) {
+        return node.node().getAttributes().containsKey(awarenessAttribute);
+    }
+
+    private String getAttributeValueForNode(final RoutingNode node, final String awarenessAttribute) {
+        return node.node().getAttributes().get(awarenessAttribute);
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDecider.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDecider.java
index efa5115939d3c..5fc3f282f33f7 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDecider.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDecider.java
@@ -140,9 +140,8 @@ public static long sizeOfRelocatingShards(
 
         // Where reserved space is unavailable (e.g. stats are out-of-sync) compute a conservative estimate for initialising shards
         final List<ShardRouting> initializingShards = node.shardsWithState(ShardRoutingState.INITIALIZING);
-        initializingShards.removeIf(shardRouting -> reservedSpace.containsShardId(shardRouting.shardId()));
         for (ShardRouting routing : initializingShards) {
-            if (routing.relocatingNodeId() == null) {
+            if (routing.relocatingNodeId() == null || reservedSpace.containsShardId(routing.shardId())) {
                 // in practice the only initializing-but-not-relocating shards with a nonzero expected shard size will be ones created
                 // by a resize (shrink/split/clone) operation which we expect to happen using hard links, so they shouldn't be taking
                 // any additional space and can be ignored here
@@ -230,7 +229,14 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing
 
         // subtractLeavingShards is passed as false here, because they still use disk space, and therefore we should be extra careful
         // and take the size into account
-        final DiskUsageWithRelocations usage = getDiskUsage(node, allocation, usages, false);
+        final DiskUsageWithRelocations usage = getDiskUsage(
+            node,
+            allocation,
+            usages,
+            clusterInfo.getAvgFreeByte(),
+            clusterInfo.getAvgTotalBytes(),
+            false
+        );
         // First, check that the node currently over the low watermark
         double freeDiskPercentage = usage.getFreeDiskAsPercentage();
         // Cache the used disk percentage for displaying disk percentages consistent with documentation
@@ -492,7 +498,14 @@ public Decision canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAl
 
         // subtractLeavingShards is passed as true here, since this is only for shards remaining, we will *eventually* have enough disk
         // since shards are moving away. No new shards will be incoming since in canAllocate we pass false for this check.
-        final DiskUsageWithRelocations usage = getDiskUsage(node, allocation, usages, true);
+        final DiskUsageWithRelocations usage = getDiskUsage(
+            node,
+            allocation,
+            usages,
+            clusterInfo.getAvgFreeByte(),
+            clusterInfo.getAvgTotalBytes(),
+            true
+        );
         final String dataPath = clusterInfo.getDataPath(shardRouting);
         // If this node is already above the high threshold, the shard cannot remain (get it off!)
         final double freeDiskPercentage = usage.getFreeDiskAsPercentage();
@@ -581,13 +594,15 @@ private DiskUsageWithRelocations getDiskUsage(
         RoutingNode node,
         RoutingAllocation allocation,
         final Map<String, DiskUsage> usages,
+        final long avgFreeBytes,
+        final long avgTotalBytes,
         boolean subtractLeavingShards
     ) {
         DiskUsage usage = usages.get(node.nodeId());
         if (usage == null) {
             // If there is no usage, and we have other nodes in the cluster,
             // use the average usage for all nodes as the usage for this node
-            usage = averageUsage(node, usages);
+            usage = new DiskUsage(node.nodeId(), node.node().getName(), "_na_", avgTotalBytes, avgFreeBytes);
             if (logger.isDebugEnabled()) {
                 logger.debug(
                     "unable to determine disk usage for {}, defaulting to average across nodes [{} total] [{} free] [{}% free]",
@@ -619,26 +634,6 @@ private DiskUsageWithRelocations getDiskUsage(
         return diskUsageWithRelocations;
     }
 
-    /**
-     * Returns a {@link DiskUsage} for the {@link RoutingNode} using the
-     * average usage of other nodes in the disk usage map.
-     * @param node Node to return an averaged DiskUsage object for
-     * @param usages Map of nodeId to DiskUsage for all known nodes
-     * @return DiskUsage representing given node using the average disk usage
-     */
-    DiskUsage averageUsage(RoutingNode node, final Map<String, DiskUsage> usages) {
-        if (usages.size() == 0) {
-            return new DiskUsage(node.nodeId(), node.node().getName(), "_na_", 0, 0);
-        }
-        long totalBytes = 0;
-        long freeBytes = 0;
-        for (DiskUsage du : usages.values()) {
-            totalBytes += du.getTotalBytes();
-            freeBytes += du.getFreeBytes();
-        }
-        return new DiskUsage(node.nodeId(), node.node().getName(), "_na_", totalBytes / usages.size(), freeBytes / usages.size());
-    }
-
     /**
      * Given the DiskUsage for a node and the size of the shard, return the
      * percentage of free disk if the shard were to be allocated to the node.
diff --git a/server/src/main/java/org/opensearch/cluster/routing/remote/InternalRemoteRoutingTableService.java b/server/src/main/java/org/opensearch/cluster/routing/remote/InternalRemoteRoutingTableService.java
index cc1b0713393f3..3c578a8c5c01f 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/remote/InternalRemoteRoutingTableService.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/remote/InternalRemoteRoutingTableService.java
@@ -11,35 +11,27 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.apache.lucene.store.IndexInput;
 import org.opensearch.action.LatchedActionListener;
-import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.Diff;
 import org.opensearch.cluster.DiffableUtils;
 import org.opensearch.cluster.routing.IndexRoutingTable;
 import org.opensearch.cluster.routing.RoutingTable;
-import org.opensearch.common.CheckedRunnable;
-import org.opensearch.common.blobstore.AsyncMultiStreamBlobContainer;
-import org.opensearch.common.blobstore.BlobContainer;
+import org.opensearch.cluster.routing.RoutingTableIncrementalDiff;
 import org.opensearch.common.blobstore.BlobPath;
-import org.opensearch.common.blobstore.stream.write.WritePriority;
-import org.opensearch.common.blobstore.transfer.RemoteTransferContainer;
-import org.opensearch.common.blobstore.transfer.stream.OffsetRangeIndexInputStream;
-import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
-import org.opensearch.common.lucene.store.ByteArrayIndexInput;
+import org.opensearch.common.remote.RemoteWritableEntityStore;
 import org.opensearch.common.settings.ClusterSettings;
-import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.core.action.ActionListener;
-import org.opensearch.core.common.bytes.BytesReference;
-import org.opensearch.core.index.Index;
+import org.opensearch.core.compress.Compressor;
 import org.opensearch.gateway.remote.ClusterMetadataManifest;
 import org.opensearch.gateway.remote.RemoteStateTransferException;
+import org.opensearch.gateway.remote.model.RemoteClusterStateBlobStore;
+import org.opensearch.gateway.remote.model.RemoteRoutingTableBlobStore;
 import org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable;
-import org.opensearch.index.remote.RemoteStoreEnums;
-import org.opensearch.index.remote.RemoteStorePathStrategy;
-import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
 import org.opensearch.node.Node;
 import org.opensearch.node.remotestore.RemoteStoreNodeAttribute;
 import org.opensearch.repositories.RepositoriesService;
@@ -52,12 +44,10 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.concurrent.ExecutorService;
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
-import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteRoutingTableEnabled;
 
 /**
@@ -67,64 +57,30 @@
  */
 public class InternalRemoteRoutingTableService extends AbstractLifecycleComponent implements RemoteRoutingTableService {
 
-    /**
-     * This setting is used to set the remote routing table store blob store path type strategy.
-     */
-    public static final Setting<RemoteStoreEnums.PathType> REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING = new Setting<>(
-        "cluster.remote_store.routing_table.path_type",
-        RemoteStoreEnums.PathType.HASHED_PREFIX.toString(),
-        RemoteStoreEnums.PathType::parseString,
-        Setting.Property.NodeScope,
-        Setting.Property.Dynamic
-    );
-
-    /**
-     * This setting is used to set the remote routing table store blob store path hash algorithm strategy.
-     * This setting will come to effect if the {@link #REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING}
-     * is either {@code HASHED_PREFIX} or {@code HASHED_INFIX}.
-     */
-    public static final Setting<RemoteStoreEnums.PathHashAlgorithm> REMOTE_ROUTING_TABLE_PATH_HASH_ALGO_SETTING = new Setting<>(
-        "cluster.remote_store.routing_table.path_hash_algo",
-        RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64.toString(),
-        RemoteStoreEnums.PathHashAlgorithm::parseString,
-        Setting.Property.NodeScope,
-        Setting.Property.Dynamic
-    );
-
-    public static final String INDEX_ROUTING_PATH_TOKEN = "index-routing";
-    public static final String INDEX_ROUTING_FILE_PREFIX = "index_routing";
-    public static final String INDEX_ROUTING_METADATA_PREFIX = "indexRouting--";
-
     private static final Logger logger = LogManager.getLogger(InternalRemoteRoutingTableService.class);
     private final Settings settings;
     private final Supplier<RepositoriesService> repositoriesService;
+    private Compressor compressor;
+    private RemoteWritableEntityStore<IndexRoutingTable, RemoteIndexRoutingTable> remoteIndexRoutingTableStore;
+    private RemoteWritableEntityStore<RoutingTableIncrementalDiff, RemoteRoutingTableDiff> remoteRoutingTableDiffStore;
+    private final ClusterSettings clusterSettings;
     private BlobStoreRepository blobStoreRepository;
-    private RemoteStoreEnums.PathType pathType;
-    private RemoteStoreEnums.PathHashAlgorithm pathHashAlgo;
-    private ThreadPool threadPool;
+    private final ThreadPool threadPool;
+    private final String clusterName;
 
     public InternalRemoteRoutingTableService(
         Supplier<RepositoriesService> repositoriesService,
         Settings settings,
         ClusterSettings clusterSettings,
-        ThreadPool threadpool
+        ThreadPool threadpool,
+        String clusterName
     ) {
         assert isRemoteRoutingTableEnabled(settings) : "Remote routing table is not enabled";
         this.repositoriesService = repositoriesService;
         this.settings = settings;
-        this.pathType = clusterSettings.get(REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING);
-        this.pathHashAlgo = clusterSettings.get(REMOTE_ROUTING_TABLE_PATH_HASH_ALGO_SETTING);
-        clusterSettings.addSettingsUpdateConsumer(REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING, this::setPathTypeSetting);
-        clusterSettings.addSettingsUpdateConsumer(REMOTE_ROUTING_TABLE_PATH_HASH_ALGO_SETTING, this::setPathHashAlgoSetting);
         this.threadPool = threadpool;
-    }
-
-    private void setPathTypeSetting(RemoteStoreEnums.PathType pathType) {
-        this.pathType = pathType;
-    }
-
-    private void setPathHashAlgoSetting(RemoteStoreEnums.PathHashAlgorithm pathHashAlgo) {
-        this.pathHashAlgo = pathHashAlgo;
+        this.clusterName = clusterName;
+        this.clusterSettings = clusterSettings;
     }
 
     public List<IndexRoutingTable> getIndicesRouting(RoutingTable routingTable) {
@@ -133,9 +89,10 @@ public List<IndexRoutingTable> getIndicesRouting(RoutingTable routingTable) {
 
     /**
      * Returns diff between the two routing tables, which includes upserts and deletes.
+     *
      * @param before previous routing table
-     * @param after current routing table
-     * @return diff of the previous and current routing table
+     * @param after  current routing table
+     * @return incremental diff of the previous and current routing table
      */
     public DiffableUtils.MapDiff<String, IndexRoutingTable, Map<String, IndexRoutingTable>> getIndicesRoutingMapDiff(
         RoutingTable before,
@@ -145,49 +102,65 @@ public DiffableUtils.MapDiff<String, IndexRoutingTable, Map<String, IndexRouting
             before.getIndicesRouting(),
             after.getIndicesRouting(),
             DiffableUtils.getStringKeySerializer(),
-            CUSTOM_ROUTING_TABLE_VALUE_SERIALIZER
+            CUSTOM_ROUTING_TABLE_DIFFABLE_VALUE_SERIALIZER
         );
     }
 
     /**
-     * Create async action for writing one {@code IndexRoutingTable} to remote store
-     * @param clusterState current cluster state
+     * Async action for writing one {@code IndexRoutingTable} to remote store
+     *
+     * @param term current term
+     * @param version current version
+     * @param clusterUUID current cluster UUID
      * @param indexRouting indexRoutingTable to write to remote store
      * @param latchedActionListener listener for handling async action response
-     * @param clusterBasePath base path for remote file
-     * @return returns runnable async action
      */
-    public CheckedRunnable<IOException> getIndexRoutingAsyncAction(
-        ClusterState clusterState,
+    @Override
+    public void getAsyncIndexRoutingWriteAction(
+        String clusterUUID,
+        long term,
+        long version,
         IndexRoutingTable indexRouting,
-        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener,
-        BlobPath clusterBasePath
+        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
     ) {
 
-        BlobPath indexRoutingPath = clusterBasePath.add(INDEX_ROUTING_PATH_TOKEN);
-        BlobPath path = pathType.path(
-            RemoteStorePathStrategy.PathInput.builder().basePath(indexRoutingPath).indexUUID(indexRouting.getIndex().getUUID()).build(),
-            pathHashAlgo
+        RemoteIndexRoutingTable remoteIndexRoutingTable = new RemoteIndexRoutingTable(indexRouting, clusterUUID, compressor, term, version);
+
+        ActionListener<Void> completionListener = ActionListener.wrap(
+            resp -> latchedActionListener.onResponse(remoteIndexRoutingTable.getUploadedMetadata()),
+            ex -> latchedActionListener.onFailure(
+                new RemoteStateTransferException("Exception in writing index to remote store: " + indexRouting.getIndex().toString(), ex)
+            )
         );
-        final BlobContainer blobContainer = blobStoreRepository.blobStore().blobContainer(path);
 
-        final String fileName = getIndexRoutingFileName(clusterState.term(), clusterState.version());
+        remoteIndexRoutingTableStore.writeAsync(remoteIndexRoutingTable, completionListener);
+    }
+
+    @Override
+    public void getAsyncIndexRoutingDiffWriteAction(
+        String clusterUUID,
+        long term,
+        long version,
+        Map<String, Diff<IndexRoutingTable>> indexRoutingTableDiff,
+        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
+    ) {
+        RoutingTableIncrementalDiff routingTableIncrementalDiff = new RoutingTableIncrementalDiff(indexRoutingTableDiff);
+        RemoteRoutingTableDiff remoteRoutingTableDiff = new RemoteRoutingTableDiff(
+            routingTableIncrementalDiff,
+            clusterUUID,
+            compressor,
+            term,
+            version
+        );
 
         ActionListener<Void> completionListener = ActionListener.wrap(
-            resp -> latchedActionListener.onResponse(
-                new ClusterMetadataManifest.UploadedIndexMetadata(
-                    indexRouting.getIndex().getName(),
-                    indexRouting.getIndex().getUUID(),
-                    path.buildAsString() + fileName,
-                    INDEX_ROUTING_METADATA_PREFIX
-                )
-            ),
+            resp -> latchedActionListener.onResponse(remoteRoutingTableDiff.getUploadedMetadata()),
             ex -> latchedActionListener.onFailure(
-                new RemoteStateTransferException("Exception in writing index to remote store: " + indexRouting.getIndex().toString(), ex)
+                new RemoteStateTransferException("Exception in writing index routing diff to remote store", ex)
             )
         );
 
-        return () -> uploadIndex(indexRouting, fileName, blobContainer, completionListener);
+        remoteRoutingTableDiffStore.writeAsync(remoteRoutingTableDiff, completionListener);
     }
 
     /**
@@ -214,111 +187,37 @@ public List<ClusterMetadataManifest.UploadedIndexMetadata> getAllUploadedIndices
         return new ArrayList<>(allUploadedIndicesRouting.values());
     }
 
-    private void uploadIndex(
-        IndexRoutingTable indexRouting,
-        String fileName,
-        BlobContainer blobContainer,
-        ActionListener<Void> completionListener
+    @Override
+    public void getAsyncIndexRoutingReadAction(
+        String clusterUUID,
+        String uploadedFilename,
+        LatchedActionListener<IndexRoutingTable> latchedActionListener
     ) {
-        RemoteIndexRoutingTable indexRoutingInput = new RemoteIndexRoutingTable(indexRouting);
-        BytesReference bytesInput = null;
-        try (BytesStreamOutput streamOutput = new BytesStreamOutput()) {
-            indexRoutingInput.writeTo(streamOutput);
-            bytesInput = streamOutput.bytes();
-        } catch (IOException e) {
-            logger.error("Failed to serialize IndexRoutingTable for [{}]: [{}]", indexRouting, e);
-            completionListener.onFailure(e);
-            return;
-        }
 
-        if (blobContainer instanceof AsyncMultiStreamBlobContainer == false) {
-            try {
-                blobContainer.writeBlob(fileName, bytesInput.streamInput(), bytesInput.length(), true);
-                completionListener.onResponse(null);
-            } catch (IOException e) {
-                logger.error("Failed to write IndexRoutingTable to remote store for indexRouting [{}]: [{}]", indexRouting, e);
-                completionListener.onFailure(e);
-            }
-            return;
-        }
+        ActionListener<IndexRoutingTable> actionListener = ActionListener.wrap(
+            latchedActionListener::onResponse,
+            latchedActionListener::onFailure
+        );
 
-        try (IndexInput input = new ByteArrayIndexInput("indexrouting", BytesReference.toBytes(bytesInput))) {
-            try (
-                RemoteTransferContainer remoteTransferContainer = new RemoteTransferContainer(
-                    fileName,
-                    fileName,
-                    input.length(),
-                    true,
-                    WritePriority.URGENT,
-                    (size, position) -> new OffsetRangeIndexInputStream(input, size, position),
-                    null,
-                    false
-                )
-            ) {
-                ((AsyncMultiStreamBlobContainer) blobContainer).asyncBlobUpload(
-                    remoteTransferContainer.createWriteContext(),
-                    completionListener
-                );
-            } catch (IOException e) {
-                logger.error("Failed to write IndexRoutingTable to remote store for indexRouting [{}]: [{}]", indexRouting, e);
-                completionListener.onFailure(e);
-            }
-        } catch (IOException e) {
-            logger.error(
-                "Failed to create transfer object for IndexRoutingTable for remote store upload for indexRouting [{}]: [{}]",
-                indexRouting,
-                e
-            );
-            completionListener.onFailure(e);
-        }
+        RemoteIndexRoutingTable remoteIndexRoutingTable = new RemoteIndexRoutingTable(uploadedFilename, clusterUUID, compressor);
+
+        remoteIndexRoutingTableStore.readAsync(remoteIndexRoutingTable, actionListener);
     }
 
     @Override
-    public CheckedRunnable<IOException> getAsyncIndexRoutingReadAction(
+    public void getAsyncIndexRoutingTableDiffReadAction(
+        String clusterUUID,
         String uploadedFilename,
-        Index index,
-        LatchedActionListener<IndexRoutingTable> latchedActionListener
+        LatchedActionListener<RoutingTableIncrementalDiff> latchedActionListener
     ) {
-        int idx = uploadedFilename.lastIndexOf("/");
-        String blobFileName = uploadedFilename.substring(idx + 1);
-        BlobContainer blobContainer = blobStoreRepository.blobStore()
-            .blobContainer(BlobPath.cleanPath().add(uploadedFilename.substring(0, idx)));
-
-        return () -> readAsync(
-            blobContainer,
-            blobFileName,
-            index,
-            threadPool.executor(ThreadPool.Names.REMOTE_STATE_READ),
-            ActionListener.wrap(
-                response -> latchedActionListener.onResponse(response.getIndexRoutingTable()),
-                latchedActionListener::onFailure
-            )
+        ActionListener<RoutingTableIncrementalDiff> actionListener = ActionListener.wrap(
+            latchedActionListener::onResponse,
+            latchedActionListener::onFailure
         );
-    }
 
-    private void readAsync(
-        BlobContainer blobContainer,
-        String name,
-        Index index,
-        ExecutorService executorService,
-        ActionListener<RemoteIndexRoutingTable> listener
-    ) {
-        executorService.execute(() -> {
-            try {
-                listener.onResponse(read(blobContainer, name, index));
-            } catch (Exception e) {
-                listener.onFailure(e);
-            }
-        });
-    }
+        RemoteRoutingTableDiff remoteRoutingTableDiff = new RemoteRoutingTableDiff(uploadedFilename, clusterUUID, compressor);
 
-    private RemoteIndexRoutingTable read(BlobContainer blobContainer, String path, Index index) {
-        try {
-            return new RemoteIndexRoutingTable(blobContainer.readBlob(path), index);
-        } catch (IOException | AssertionError e) {
-            logger.error(() -> new ParameterizedMessage("RoutingTable read failed for path {}", path), e);
-            throw new RemoteStateTransferException("Failed to read RemoteRoutingTable from Manifest with error ", e);
-        }
+        remoteRoutingTableDiffStore.readAsync(remoteRoutingTableDiff, actionListener);
     }
 
     @Override
@@ -335,16 +234,6 @@ public List<ClusterMetadataManifest.UploadedIndexMetadata> getUpdatedIndexRoutin
         }).collect(Collectors.toList());
     }
 
-    private String getIndexRoutingFileName(long term, long version) {
-        return String.join(
-            DELIMITER,
-            INDEX_ROUTING_FILE_PREFIX,
-            RemoteStoreUtils.invertLong(term),
-            RemoteStoreUtils.invertLong(version),
-            RemoteStoreUtils.invertLong(System.currentTimeMillis())
-        );
-    }
-
     @Override
     protected void doClose() throws IOException {
         if (blobStoreRepository != null) {
@@ -362,6 +251,24 @@ protected void doStart() {
         final Repository repository = repositoriesService.get().repository(remoteStoreRepo);
         assert repository instanceof BlobStoreRepository : "Repository should be instance of BlobStoreRepository";
         blobStoreRepository = (BlobStoreRepository) repository;
+        compressor = blobStoreRepository.getCompressor();
+
+        this.remoteIndexRoutingTableStore = new RemoteRoutingTableBlobStore<>(
+            new BlobStoreTransferService(blobStoreRepository.blobStore(), threadPool),
+            blobStoreRepository,
+            clusterName,
+            threadPool,
+            ThreadPool.Names.REMOTE_STATE_READ,
+            clusterSettings
+        );
+
+        this.remoteRoutingTableDiffStore = new RemoteClusterStateBlobStore<>(
+            new BlobStoreTransferService(blobStoreRepository.blobStore(), threadPool),
+            blobStoreRepository,
+            clusterName,
+            threadPool,
+            ThreadPool.Names.REMOTE_STATE_READ
+        );
     }
 
     @Override
@@ -378,4 +285,13 @@ public void deleteStaleIndexRoutingPaths(List<String> stalePaths) throws IOExcep
         }
     }
 
+    public void deleteStaleIndexRoutingDiffPaths(List<String> stalePaths) throws IOException {
+        try {
+            logger.debug(() -> "Deleting stale index routing diff files from remote - " + stalePaths);
+            blobStoreRepository.blobStore().blobContainer(BlobPath.cleanPath()).deleteBlobsIgnoringIfNotExists(stalePaths);
+        } catch (IOException e) {
+            logger.error(() -> new ParameterizedMessage("Failed to delete some stale index routing diff paths from {}", stalePaths), e);
+            throw e;
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/remote/NoopRemoteRoutingTableService.java b/server/src/main/java/org/opensearch/cluster/routing/remote/NoopRemoteRoutingTableService.java
index 6236d107d0220..1ebf3206212a1 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/remote/NoopRemoteRoutingTableService.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/remote/NoopRemoteRoutingTableService.java
@@ -9,14 +9,12 @@
 package org.opensearch.cluster.routing.remote;
 
 import org.opensearch.action.LatchedActionListener;
-import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.Diff;
 import org.opensearch.cluster.DiffableUtils;
 import org.opensearch.cluster.routing.IndexRoutingTable;
 import org.opensearch.cluster.routing.RoutingTable;
-import org.opensearch.common.CheckedRunnable;
-import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.cluster.routing.RoutingTableIncrementalDiff;
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
-import org.opensearch.core.index.Index;
 import org.opensearch.gateway.remote.ClusterMetadataManifest;
 
 import java.io.IOException;
@@ -38,18 +36,34 @@ public DiffableUtils.MapDiff<String, IndexRoutingTable, Map<String, IndexRouting
         RoutingTable before,
         RoutingTable after
     ) {
-        return DiffableUtils.diff(Map.of(), Map.of(), DiffableUtils.getStringKeySerializer(), CUSTOM_ROUTING_TABLE_VALUE_SERIALIZER);
+        return DiffableUtils.diff(
+            Map.of(),
+            Map.of(),
+            DiffableUtils.getStringKeySerializer(),
+            CUSTOM_ROUTING_TABLE_DIFFABLE_VALUE_SERIALIZER
+        );
     }
 
     @Override
-    public CheckedRunnable<IOException> getIndexRoutingAsyncAction(
-        ClusterState clusterState,
+    public void getAsyncIndexRoutingWriteAction(
+        String clusterUUID,
+        long term,
+        long version,
         IndexRoutingTable indexRouting,
-        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener,
-        BlobPath clusterBasePath
+        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
+    ) {
+        // noop
+    }
+
+    @Override
+    public void getAsyncIndexRoutingDiffWriteAction(
+        String clusterUUID,
+        long term,
+        long version,
+        Map<String, Diff<IndexRoutingTable>> indexRoutingTableDiff,
+        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
     ) {
         // noop
-        return () -> {};
     }
 
     @Override
@@ -63,13 +77,21 @@ public List<ClusterMetadataManifest.UploadedIndexMetadata> getAllUploadedIndices
     }
 
     @Override
-    public CheckedRunnable<IOException> getAsyncIndexRoutingReadAction(
+    public void getAsyncIndexRoutingReadAction(
+        String clusterUUID,
         String uploadedFilename,
-        Index index,
         LatchedActionListener<IndexRoutingTable> latchedActionListener
     ) {
         // noop
-        return () -> {};
+    }
+
+    @Override
+    public void getAsyncIndexRoutingTableDiffReadAction(
+        String clusterUUID,
+        String uploadedFilename,
+        LatchedActionListener<RoutingTableIncrementalDiff> latchedActionListener
+    ) {
+        // noop
     }
 
     @Override
@@ -100,4 +122,8 @@ protected void doClose() throws IOException {
     public void deleteStaleIndexRoutingPaths(List<String> stalePaths) throws IOException {
         // noop
     }
+
+    public void deleteStaleIndexRoutingDiffPaths(List<String> stalePaths) throws IOException {
+        // noop
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableService.java b/server/src/main/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableService.java
index d455dfb58eabc..0811a5f3010f4 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableService.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableService.java
@@ -9,19 +9,19 @@
 package org.opensearch.cluster.routing.remote;
 
 import org.opensearch.action.LatchedActionListener;
-import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.Diff;
 import org.opensearch.cluster.DiffableUtils;
 import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.IndexShardRoutingTable;
 import org.opensearch.cluster.routing.RoutingTable;
-import org.opensearch.common.CheckedRunnable;
-import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.cluster.routing.RoutingTableIncrementalDiff;
 import org.opensearch.common.lifecycle.LifecycleComponent;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.core.index.Index;
 import org.opensearch.gateway.remote.ClusterMetadataManifest;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
@@ -31,27 +31,53 @@
  * @opensearch.internal
  */
 public interface RemoteRoutingTableService extends LifecycleComponent {
-    public static final DiffableUtils.NonDiffableValueSerializer<String, IndexRoutingTable> CUSTOM_ROUTING_TABLE_VALUE_SERIALIZER =
-        new DiffableUtils.NonDiffableValueSerializer<String, IndexRoutingTable>() {
+
+    public static final DiffableUtils.DiffableValueSerializer<String, IndexRoutingTable> CUSTOM_ROUTING_TABLE_DIFFABLE_VALUE_SERIALIZER =
+        new DiffableUtils.DiffableValueSerializer<String, IndexRoutingTable>() {
+            @Override
+            public IndexRoutingTable read(StreamInput in, String key) throws IOException {
+                return IndexRoutingTable.readFrom(in);
+            }
+
             @Override
             public void write(IndexRoutingTable value, StreamOutput out) throws IOException {
                 value.writeTo(out);
             }
 
             @Override
-            public IndexRoutingTable read(StreamInput in, String key) throws IOException {
-                return IndexRoutingTable.readFrom(in);
+            public Diff<IndexRoutingTable> readDiff(StreamInput in, String key) throws IOException {
+                return IndexRoutingTable.readDiffFrom(in);
+            }
+
+            @Override
+            public Diff<IndexRoutingTable> diff(IndexRoutingTable currentState, IndexRoutingTable previousState) {
+                List<IndexShardRoutingTable> diffs = new ArrayList<>();
+                for (Map.Entry<Integer, IndexShardRoutingTable> entry : currentState.getShards().entrySet()) {
+                    Integer index = entry.getKey();
+                    IndexShardRoutingTable currentShardRoutingTable = entry.getValue();
+                    IndexShardRoutingTable previousShardRoutingTable = previousState.shard(index);
+                    if (previousShardRoutingTable == null || !previousShardRoutingTable.equals(currentShardRoutingTable)) {
+                        diffs.add(currentShardRoutingTable);
+                    }
+                }
+                return new RoutingTableIncrementalDiff.IndexRoutingTableIncrementalDiff(diffs);
             }
         };
 
     List<IndexRoutingTable> getIndicesRouting(RoutingTable routingTable);
 
-    CheckedRunnable<IOException> getAsyncIndexRoutingReadAction(
+    void getAsyncIndexRoutingReadAction(
+        String clusterUUID,
         String uploadedFilename,
-        Index index,
         LatchedActionListener<IndexRoutingTable> latchedActionListener
     );
 
+    void getAsyncIndexRoutingTableDiffReadAction(
+        String clusterUUID,
+        String uploadedFilename,
+        LatchedActionListener<RoutingTableIncrementalDiff> latchedActionListener
+    );
+
     List<ClusterMetadataManifest.UploadedIndexMetadata> getUpdatedIndexRoutingTableMetadata(
         List<String> updatedIndicesRouting,
         List<ClusterMetadataManifest.UploadedIndexMetadata> allIndicesRouting
@@ -62,11 +88,20 @@ DiffableUtils.MapDiff<String, IndexRoutingTable, Map<String, IndexRoutingTable>>
         RoutingTable after
     );
 
-    CheckedRunnable<IOException> getIndexRoutingAsyncAction(
-        ClusterState clusterState,
+    void getAsyncIndexRoutingWriteAction(
+        String clusterUUID,
+        long term,
+        long version,
         IndexRoutingTable indexRouting,
-        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener,
-        BlobPath clusterBasePath
+        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
+    );
+
+    void getAsyncIndexRoutingDiffWriteAction(
+        String clusterUUID,
+        long term,
+        long version,
+        Map<String, Diff<IndexRoutingTable>> indexRoutingTableDiff,
+        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
     );
 
     List<ClusterMetadataManifest.UploadedIndexMetadata> getAllUploadedIndicesRouting(
@@ -77,4 +112,6 @@ List<ClusterMetadataManifest.UploadedIndexMetadata> getAllUploadedIndicesRouting
 
     public void deleteStaleIndexRoutingPaths(List<String> stalePaths) throws IOException;
 
+    public void deleteStaleIndexRoutingDiffPaths(List<String> stalePaths) throws IOException;
+
 }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceFactory.java b/server/src/main/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceFactory.java
index 82837191a30b7..56dfa03215a64 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceFactory.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceFactory.java
@@ -34,10 +34,11 @@ public static RemoteRoutingTableService getService(
         Supplier<RepositoriesService> repositoriesService,
         Settings settings,
         ClusterSettings clusterSettings,
-        ThreadPool threadPool
+        ThreadPool threadPool,
+        String clusterName
     ) {
         if (isRemoteRoutingTableEnabled(settings)) {
-            return new InternalRemoteRoutingTableService(repositoriesService, settings, clusterSettings, threadPool);
+            return new InternalRemoteRoutingTableService(repositoriesService, settings, clusterSettings, threadPool, clusterName);
         }
         return new NoopRemoteRoutingTableService();
     }
diff --git a/server/src/main/java/org/opensearch/cluster/service/MasterService.java b/server/src/main/java/org/opensearch/cluster/service/MasterService.java
index bbeb0cc4b8f88..bb820e9a20fe0 100644
--- a/server/src/main/java/org/opensearch/cluster/service/MasterService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/MasterService.java
@@ -86,6 +86,7 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
@@ -225,10 +226,10 @@ protected void onTimeout(List<? extends BatchedTask> tasks, TimeValue timeout) {
         }
 
         @Override
-        protected void run(Object batchingKey, List<? extends BatchedTask> tasks, String tasksSummary) {
+        protected void run(Object batchingKey, List<? extends BatchedTask> tasks, Function<Boolean, String> taskSummaryGenerator) {
             ClusterStateTaskExecutor<Object> taskExecutor = (ClusterStateTaskExecutor<Object>) batchingKey;
             List<UpdateTask> updateTasks = (List<UpdateTask>) tasks;
-            runTasks(new TaskInputs(taskExecutor, updateTasks, tasksSummary));
+            runTasks(new TaskInputs(taskExecutor, updateTasks, taskSummaryGenerator));
         }
 
         class UpdateTask extends BatchedTask {
@@ -301,26 +302,33 @@ public static boolean assertNotMasterUpdateThread(String reason) {
     }
 
     private void runTasks(TaskInputs taskInputs) {
-        final String summary = taskInputs.summary;
+        final String longSummary = logger.isTraceEnabled() ? taskInputs.taskSummaryGenerator.apply(true) : "";
+        final String shortSummary = taskInputs.taskSummaryGenerator.apply(false);
+
         if (!lifecycle.started()) {
-            logger.debug("processing [{}]: ignoring, cluster-manager service not started", summary);
+            logger.debug("processing [{}]: ignoring, cluster-manager service not started", shortSummary);
             return;
         }
 
-        logger.debug("executing cluster state update for [{}]", summary);
+        if (logger.isTraceEnabled()) {
+            logger.trace("executing cluster state update for [{}]", longSummary);
+        } else {
+            logger.debug("executing cluster state update for [{}]", shortSummary);
+        }
+
         final ClusterState previousClusterState = state();
 
         if (!previousClusterState.nodes().isLocalNodeElectedClusterManager() && taskInputs.runOnlyWhenClusterManager()) {
-            logger.debug("failing [{}]: local node is no longer cluster-manager", summary);
+            logger.debug("failing [{}]: local node is no longer cluster-manager", shortSummary);
             taskInputs.onNoLongerClusterManager();
             return;
         }
 
         final long computationStartTime = threadPool.preciseRelativeTimeInNanos();
-        final TaskOutputs taskOutputs = calculateTaskOutputs(taskInputs, previousClusterState);
+        final TaskOutputs taskOutputs = calculateTaskOutputs(taskInputs, previousClusterState, shortSummary);
         taskOutputs.notifyFailedTasks();
         final TimeValue computationTime = getTimeSince(computationStartTime);
-        logExecutionTime(computationTime, "compute cluster state update", summary);
+        logExecutionTime(computationTime, "compute cluster state update", shortSummary);
 
         clusterManagerMetrics.recordLatency(
             clusterManagerMetrics.clusterStateComputeHistogram,
@@ -332,17 +340,17 @@ private void runTasks(TaskInputs taskInputs) {
             final long notificationStartTime = threadPool.preciseRelativeTimeInNanos();
             taskOutputs.notifySuccessfulTasksOnUnchangedClusterState();
             final TimeValue executionTime = getTimeSince(notificationStartTime);
-            logExecutionTime(executionTime, "notify listeners on unchanged cluster state", summary);
+            logExecutionTime(executionTime, "notify listeners on unchanged cluster state", shortSummary);
         } else {
             final ClusterState newClusterState = taskOutputs.newClusterState;
             if (logger.isTraceEnabled()) {
-                logger.trace("cluster state updated, source [{}]\n{}", summary, newClusterState);
+                logger.trace("cluster state updated, source [{}]\n{}", longSummary, newClusterState);
             } else {
-                logger.debug("cluster state updated, version [{}], source [{}]", newClusterState.version(), summary);
+                logger.debug("cluster state updated, version [{}], source [{}]", newClusterState.version(), shortSummary);
             }
             final long publicationStartTime = threadPool.preciseRelativeTimeInNanos();
             try {
-                ClusterChangedEvent clusterChangedEvent = new ClusterChangedEvent(summary, newClusterState, previousClusterState);
+                ClusterChangedEvent clusterChangedEvent = new ClusterChangedEvent(shortSummary, newClusterState, previousClusterState);
                 // new cluster state, notify all listeners
                 final DiscoveryNodes.Delta nodesDelta = clusterChangedEvent.nodesDelta();
                 if (nodesDelta.hasChanges() && logger.isInfoEnabled()) {
@@ -350,7 +358,7 @@ private void runTasks(TaskInputs taskInputs) {
                     if (nodesDeltaSummary.length() > 0) {
                         logger.info(
                             "{}, term: {}, version: {}, delta: {}",
-                            summary,
+                            shortSummary,
                             newClusterState.term(),
                             newClusterState.version(),
                             nodesDeltaSummary
@@ -361,7 +369,7 @@ private void runTasks(TaskInputs taskInputs) {
                 logger.debug("publishing cluster state version [{}]", newClusterState.version());
                 publish(clusterChangedEvent, taskOutputs, publicationStartTime);
             } catch (Exception e) {
-                handleException(summary, publicationStartTime, newClusterState, e);
+                handleException(shortSummary, publicationStartTime, newClusterState, e);
             }
         }
     }
@@ -456,8 +464,8 @@ private void handleException(String summary, long startTimeMillis, ClusterState
         // TODO: do we want to call updateTask.onFailure here?
     }
 
-    private TaskOutputs calculateTaskOutputs(TaskInputs taskInputs, ClusterState previousClusterState) {
-        ClusterTasksResult<Object> clusterTasksResult = executeTasks(taskInputs, previousClusterState);
+    private TaskOutputs calculateTaskOutputs(TaskInputs taskInputs, ClusterState previousClusterState, String taskSummary) {
+        ClusterTasksResult<Object> clusterTasksResult = executeTasks(taskInputs, previousClusterState, taskSummary);
         ClusterState newClusterState = patchVersions(previousClusterState, clusterTasksResult);
         return new TaskOutputs(
             taskInputs,
@@ -901,7 +909,7 @@ public void onTimeout() {
         }
     }
 
-    private ClusterTasksResult<Object> executeTasks(TaskInputs taskInputs, ClusterState previousClusterState) {
+    private ClusterTasksResult<Object> executeTasks(TaskInputs taskInputs, ClusterState previousClusterState, String taskSummary) {
         ClusterTasksResult<Object> clusterTasksResult;
         try {
             List<Object> inputs = taskInputs.updateTasks.stream().map(tUpdateTask -> tUpdateTask.task).collect(Collectors.toList());
@@ -917,7 +925,7 @@ private ClusterTasksResult<Object> executeTasks(TaskInputs taskInputs, ClusterSt
                     "failed to execute cluster state update (on version: [{}], uuid: [{}]) for [{}]\n{}{}{}",
                     previousClusterState.version(),
                     previousClusterState.stateUUID(),
-                    taskInputs.summary,
+                    taskSummary,
                     previousClusterState.nodes(),
                     previousClusterState.routingTable(),
                     previousClusterState.getRoutingNodes()
@@ -959,14 +967,19 @@ private List<Batcher.UpdateTask> getNonFailedTasks(TaskInputs taskInputs, Cluste
      * Represents a set of tasks to be processed together with their executor
      */
     private class TaskInputs {
-        final String summary;
+
         final List<Batcher.UpdateTask> updateTasks;
         final ClusterStateTaskExecutor<Object> executor;
+        final Function<Boolean, String> taskSummaryGenerator;
 
-        TaskInputs(ClusterStateTaskExecutor<Object> executor, List<Batcher.UpdateTask> updateTasks, String summary) {
-            this.summary = summary;
+        TaskInputs(
+            ClusterStateTaskExecutor<Object> executor,
+            List<Batcher.UpdateTask> updateTasks,
+            final Function<Boolean, String> taskSummaryGenerator
+        ) {
             this.executor = executor;
             this.updateTasks = updateTasks;
+            this.taskSummaryGenerator = taskSummaryGenerator;
         }
 
         boolean runOnlyWhenClusterManager() {
diff --git a/server/src/main/java/org/opensearch/cluster/service/TaskBatcher.java b/server/src/main/java/org/opensearch/cluster/service/TaskBatcher.java
index 5e58f495a16fb..3513bfffb7157 100644
--- a/server/src/main/java/org/opensearch/cluster/service/TaskBatcher.java
+++ b/server/src/main/java/org/opensearch/cluster/service/TaskBatcher.java
@@ -177,7 +177,6 @@ void runIfNotProcessed(BatchedTask updateTask) {
         // to give other tasks with different batching key a chance to execute.
         if (updateTask.processed.get() == false) {
             final List<BatchedTask> toExecute = new ArrayList<>();
-            final Map<String, List<BatchedTask>> processTasksBySource = new HashMap<>();
             // While removing task, need to remove task first from taskMap and then remove identity from identityMap.
             // Changing this order might lead to duplicate task during submission.
             LinkedHashSet<BatchedTask> pending = tasksPerBatchingKey.remove(updateTask.batchingKey);
@@ -187,7 +186,6 @@ void runIfNotProcessed(BatchedTask updateTask) {
                     if (task.processed.getAndSet(true) == false) {
                         logger.trace("will process {}", task);
                         toExecute.add(task);
-                        processTasksBySource.computeIfAbsent(task.source, s -> new ArrayList<>()).add(task);
                     } else {
                         logger.trace("skipping {}, already processed", task);
                     }
@@ -195,22 +193,34 @@ void runIfNotProcessed(BatchedTask updateTask) {
             }
 
             if (toExecute.isEmpty() == false) {
-                final String tasksSummary = processTasksBySource.entrySet().stream().map(entry -> {
-                    String tasks = updateTask.describeTasks(entry.getValue());
-                    return tasks.isEmpty() ? entry.getKey() : entry.getKey() + "[" + tasks + "]";
-                }).reduce((s1, s2) -> s1 + ", " + s2).orElse("");
-
+                Function<Boolean, String> taskSummaryGenerator = (longSummaryRequired) -> {
+                    if (longSummaryRequired == null || !longSummaryRequired) {
+                        return buildShortSummary(updateTask.batchingKey, toExecute.size());
+                    }
+                    final Map<String, List<BatchedTask>> processTasksBySource = new HashMap<>();
+                    for (final BatchedTask task : toExecute) {
+                        processTasksBySource.computeIfAbsent(task.source, s -> new ArrayList<>()).add(task);
+                    }
+                    return processTasksBySource.entrySet().stream().map(entry -> {
+                        String tasks = updateTask.describeTasks(entry.getValue());
+                        return tasks.isEmpty() ? entry.getKey() : entry.getKey() + "[" + tasks + "]";
+                    }).reduce((s1, s2) -> s1 + ", " + s2).orElse("");
+                };
                 taskBatcherListener.onBeginProcessing(toExecute);
-                run(updateTask.batchingKey, toExecute, tasksSummary);
+                run(updateTask.batchingKey, toExecute, taskSummaryGenerator);
             }
         }
     }
 
+    private String buildShortSummary(final Object batchingKey, final int taskCount) {
+        return "Tasks batched with key: " + batchingKey.toString().split("\\$")[0] + " and count: " + taskCount;
+    }
+
     /**
      * Action to be implemented by the specific batching implementation
      * All tasks have the given batching key.
      */
-    protected abstract void run(Object batchingKey, List<? extends BatchedTask> tasks, String tasksSummary);
+    protected abstract void run(Object batchingKey, List<? extends BatchedTask> tasks, Function<Boolean, String> taskSummaryGenerator);
 
     /**
      * Represents a runnable task that supports batching.
diff --git a/server/src/main/java/org/opensearch/common/remote/AbstractRemoteWritableBlobEntity.java b/server/src/main/java/org/opensearch/common/remote/AbstractRemoteWritableBlobEntity.java
index 23fc9d3ad77cb..237c077cb673c 100644
--- a/server/src/main/java/org/opensearch/common/remote/AbstractRemoteWritableBlobEntity.java
+++ b/server/src/main/java/org/opensearch/common/remote/AbstractRemoteWritableBlobEntity.java
@@ -40,6 +40,10 @@ public AbstractRemoteWritableBlobEntity(
         this.namedXContentRegistry = namedXContentRegistry;
     }
 
+    public AbstractRemoteWritableBlobEntity(final String clusterUUID, final Compressor compressor) {
+        this(clusterUUID, compressor, null);
+    }
+
     public abstract BlobPathParameters getBlobPathParameters();
 
     public abstract String getType();
diff --git a/server/src/main/java/org/opensearch/common/remote/AbstractRemoteWritableEntityManager.java b/server/src/main/java/org/opensearch/common/remote/AbstractRemoteWritableEntityManager.java
new file mode 100644
index 0000000000000..dc301635c4a80
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/remote/AbstractRemoteWritableEntityManager.java
@@ -0,0 +1,84 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.remote;
+
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.model.RemoteReadResult;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * An abstract class that provides a base implementation for managing remote entities in the remote store.
+ */
+public abstract class AbstractRemoteWritableEntityManager implements RemoteWritableEntityManager {
+    /**
+     * A map that stores the remote writable entity stores, keyed by the entity type.
+     */
+    protected final Map<String, RemoteWritableEntityStore> remoteWritableEntityStores = new HashMap<>();
+
+    /**
+     * Retrieves the remote writable entity store for the given entity.
+     *
+     * @param entity the entity for which the store is requested
+     * @return the remote writable entity store for the given entity
+     * @throws IllegalArgumentException if the entity type is unknown
+     */
+    protected RemoteWritableEntityStore getStore(AbstractRemoteWritableBlobEntity entity) {
+        RemoteWritableEntityStore remoteStore = remoteWritableEntityStores.get(entity.getType());
+        if (remoteStore == null) {
+            throw new IllegalArgumentException("Unknown entity type [" + entity.getType() + "]");
+        }
+        return remoteStore;
+    }
+
+    /**
+     * Returns an ActionListener for handling the write operation for the specified component, remote object, and latched action listener.
+     *
+     * @param component the component for which the write operation is performed
+     * @param remoteEntity the remote object to be written
+     * @param listener the listener to be notified when the write operation completes
+     * @return an ActionListener for handling the write operation
+     */
+    protected abstract ActionListener<Void> getWrappedWriteListener(
+        String component,
+        AbstractRemoteWritableBlobEntity remoteEntity,
+        ActionListener<ClusterMetadataManifest.UploadedMetadata> listener
+    );
+
+    /**
+     * Returns an ActionListener for handling the read operation for the specified component,
+     * remote object, and latched action listener.
+     *
+     * @param component the component for which the read operation is performed
+     * @param remoteEntity the remote object to be read
+     * @param listener the listener to be notified when the read operation completes
+     * @return an ActionListener for handling the read operation
+     */
+    protected abstract ActionListener<Object> getWrappedReadListener(
+        String component,
+        AbstractRemoteWritableBlobEntity remoteEntity,
+        ActionListener<RemoteReadResult> listener
+    );
+
+    @Override
+    public void writeAsync(
+        String component,
+        AbstractRemoteWritableBlobEntity entity,
+        ActionListener<ClusterMetadataManifest.UploadedMetadata> listener
+    ) {
+        getStore(entity).writeAsync(entity, getWrappedWriteListener(component, entity, listener));
+    }
+
+    @Override
+    public void readAsync(String component, AbstractRemoteWritableBlobEntity entity, ActionListener<RemoteReadResult> listener) {
+        getStore(entity).readAsync(entity, getWrappedReadListener(component, entity, listener));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/remote/RemoteWritableEntityManager.java b/server/src/main/java/org/opensearch/common/remote/RemoteWritableEntityManager.java
new file mode 100644
index 0000000000000..7693d1b5284bd
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/remote/RemoteWritableEntityManager.java
@@ -0,0 +1,47 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.remote;
+
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.model.RemoteReadResult;
+
+/**
+ * The RemoteWritableEntityManager interface provides async read and write methods for managing remote entities in the remote store
+ */
+public interface RemoteWritableEntityManager {
+
+    /**
+     * Performs an asynchronous read operation for the specified component and entity.
+     *
+     * @param component the component for which the read operation is performed
+     * @param entity the entity to be read
+     * @param listener the listener to be notified when the read operation completes.
+     *                 The listener's {@link ActionListener#onResponse(Object)} method
+     *                 is called with a {@link RemoteReadResult} object containing the
+     *                 read data on successful read. The
+     *                 {@link ActionListener#onFailure(Exception)} method is called with
+     *                 an exception if the read operation fails.
+     */
+    void readAsync(String component, AbstractRemoteWritableBlobEntity entity, ActionListener<RemoteReadResult> listener);
+
+    /**
+     * Performs an asynchronous write operation for the specified component and entity.
+     *
+     * @param component the component for which the write operation is performed
+     * @param entity the entity to be written
+     * @param listener the listener to be notified when the write operation completes.
+     *                 The listener's {@link ActionListener#onResponse(Object)} method
+     *                 is called with a {@link UploadedMetadata} object containing the
+     *                 uploaded metadata on successful write. The
+     *                 {@link ActionListener#onFailure(Exception)} method is called with
+     *                 an exception if the write operation fails.
+     */
+    void writeAsync(String component, AbstractRemoteWritableBlobEntity entity, ActionListener<UploadedMetadata> listener);
+}
diff --git a/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java b/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
index 0648fad619dc7..49801fd3834b8 100644
--- a/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
+++ b/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
@@ -49,6 +49,7 @@
 import org.opensearch.cluster.NodeConnectionsService;
 import org.opensearch.cluster.action.index.MappingUpdatedAction;
 import org.opensearch.cluster.action.shard.ShardStateAction;
+import org.opensearch.cluster.applicationtemplates.SystemTemplatesService;
 import org.opensearch.cluster.coordination.ClusterBootstrapService;
 import org.opensearch.cluster.coordination.ClusterFormationFailureHelper;
 import org.opensearch.cluster.coordination.Coordinator;
@@ -77,7 +78,6 @@
 import org.opensearch.cluster.routing.allocation.decider.SameShardAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.ShardsLimitAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.ThrottlingAllocationDecider;
-import org.opensearch.cluster.routing.remote.InternalRemoteRoutingTableService;
 import org.opensearch.cluster.service.ClusterApplierService;
 import org.opensearch.cluster.service.ClusterManagerService;
 import org.opensearch.cluster.service.ClusterManagerTaskThrottler;
@@ -107,6 +107,7 @@
 import org.opensearch.gateway.ShardsBatchGatewayAllocator;
 import org.opensearch.gateway.remote.RemoteClusterStateCleanupManager;
 import org.opensearch.gateway.remote.RemoteClusterStateService;
+import org.opensearch.gateway.remote.model.RemoteRoutingTableBlobStore;
 import org.opensearch.http.HttpTransportSettings;
 import org.opensearch.index.IndexModule;
 import org.opensearch.index.IndexSettings;
@@ -729,8 +730,8 @@ public void apply(Settings value, Settings current, Settings previous) {
                 RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING,
                 IndicesService.CLUSTER_REMOTE_INDEX_RESTRICT_ASYNC_DURABILITY_SETTING,
                 IndicesService.CLUSTER_INDEX_RESTRICT_REPLICATION_TYPE_SETTING,
-                InternalRemoteRoutingTableService.REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING,
-                InternalRemoteRoutingTableService.REMOTE_ROUTING_TABLE_PATH_HASH_ALGO_SETTING,
+                RemoteRoutingTableBlobStore.REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING,
+                RemoteRoutingTableBlobStore.REMOTE_ROUTING_TABLE_PATH_HASH_ALGO_SETTING,
 
                 // Admission Control Settings
                 AdmissionControlSettings.ADMISSION_CONTROL_TRANSPORT_LAYER_MODE,
@@ -757,7 +758,9 @@ public void apply(Settings value, Settings current, Settings previous) {
                 SearchService.CLUSTER_ALLOW_DERIVED_FIELD_SETTING,
 
                 // Composite index settings
-                CompositeIndexSettings.STAR_TREE_INDEX_ENABLED_SETTING
+                CompositeIndexSettings.STAR_TREE_INDEX_ENABLED_SETTING,
+
+                SystemTemplatesService.SETTING_APPLICATION_BASED_CONFIGURATION_TEMPLATES_ENABLED
             )
         )
     );
diff --git a/server/src/main/java/org/opensearch/common/settings/FeatureFlagSettings.java b/server/src/main/java/org/opensearch/common/settings/FeatureFlagSettings.java
index b6166f5d3cce1..d893d8d92be3b 100644
--- a/server/src/main/java/org/opensearch/common/settings/FeatureFlagSettings.java
+++ b/server/src/main/java/org/opensearch/common/settings/FeatureFlagSettings.java
@@ -38,6 +38,7 @@ protected FeatureFlagSettings(
         FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL_SETTING,
         FeatureFlags.PLUGGABLE_CACHE_SETTING,
         FeatureFlags.REMOTE_PUBLICATION_EXPERIMENTAL_SETTING,
-        FeatureFlags.STAR_TREE_INDEX_SETTING
+        FeatureFlags.STAR_TREE_INDEX_SETTING,
+        FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES_SETTING
     );
 }
diff --git a/server/src/main/java/org/opensearch/common/settings/IndexScopedSettings.java b/server/src/main/java/org/opensearch/common/settings/IndexScopedSettings.java
index ca2c4dab6102b..6e7d77d0c00d4 100644
--- a/server/src/main/java/org/opensearch/common/settings/IndexScopedSettings.java
+++ b/server/src/main/java/org/opensearch/common/settings/IndexScopedSettings.java
@@ -273,7 +273,7 @@ public final class IndexScopedSettings extends AbstractScopedSettings {
      */
     public static final Map<String, List<Setting>> FEATURE_FLAGGED_INDEX_SETTINGS = Map.of(
         FeatureFlags.TIERED_REMOTE_INDEX,
-        List.of(IndexModule.INDEX_STORE_LOCALITY_SETTING)
+        List.of(IndexModule.INDEX_STORE_LOCALITY_SETTING, IndexModule.INDEX_TIERING_STATE)
     );
 
     public static final IndexScopedSettings DEFAULT_SCOPED_SETTINGS = new IndexScopedSettings(Settings.EMPTY, BUILT_IN_INDEX_SETTINGS);
diff --git a/server/src/main/java/org/opensearch/common/util/FeatureFlags.java b/server/src/main/java/org/opensearch/common/util/FeatureFlags.java
index ceb2559a0e16c..9d57e6939e3ae 100644
--- a/server/src/main/java/org/opensearch/common/util/FeatureFlags.java
+++ b/server/src/main/java/org/opensearch/common/util/FeatureFlags.java
@@ -107,6 +107,16 @@ public class FeatureFlags {
     public static final String STAR_TREE_INDEX = "opensearch.experimental.feature.composite_index.star_tree.enabled";
     public static final Setting<Boolean> STAR_TREE_INDEX_SETTING = Setting.boolSetting(STAR_TREE_INDEX, false, Property.NodeScope);
 
+    /**
+     * Gates the functionality of application based configuration templates.
+     */
+    public static final String APPLICATION_BASED_CONFIGURATION_TEMPLATES = "opensearch.experimental.feature.application_templates.enabled";
+    public static final Setting<Boolean> APPLICATION_BASED_CONFIGURATION_TEMPLATES_SETTING = Setting.boolSetting(
+        APPLICATION_BASED_CONFIGURATION_TEMPLATES,
+        false,
+        Property.NodeScope
+    );
+
     private static final List<Setting<Boolean>> ALL_FEATURE_FLAG_SETTINGS = List.of(
         REMOTE_STORE_MIGRATION_EXPERIMENTAL_SETTING,
         EXTENSIONS_SETTING,
@@ -116,8 +126,10 @@ public class FeatureFlags {
         TIERED_REMOTE_INDEX_SETTING,
         PLUGGABLE_CACHE_SETTING,
         REMOTE_PUBLICATION_EXPERIMENTAL_SETTING,
-        STAR_TREE_INDEX_SETTING
+        STAR_TREE_INDEX_SETTING,
+        APPLICATION_BASED_CONFIGURATION_TEMPLATES_SETTING
     );
+
     /**
      * Should store the settings from opensearch.yml.
      */
diff --git a/server/src/main/java/org/opensearch/gateway/ReplicaShardAllocator.java b/server/src/main/java/org/opensearch/gateway/ReplicaShardAllocator.java
index d9474b32bdbf6..aaf0d696e1444 100644
--- a/server/src/main/java/org/opensearch/gateway/ReplicaShardAllocator.java
+++ b/server/src/main/java/org/opensearch/gateway/ReplicaShardAllocator.java
@@ -100,7 +100,10 @@ protected Runnable cancelExistingRecoveryForBetterMatch(
         Metadata metadata = allocation.metadata();
         RoutingNodes routingNodes = allocation.routingNodes();
         ShardRouting primaryShard = allocation.routingNodes().activePrimary(shard.shardId());
-        assert primaryShard != null : "the replica shard can be allocated on at least one node, so there must be an active primary";
+        if (primaryShard == null) {
+            logger.trace("{}: no active primary shard found or allocated, letting actual allocation figure it out", shard);
+            return null;
+        }
         assert primaryShard.currentNodeId() != null;
         final DiscoveryNode primaryNode = allocation.nodes().get(primaryShard.currentNodeId());
 
diff --git a/server/src/main/java/org/opensearch/gateway/remote/ClusterMetadataManifest.java b/server/src/main/java/org/opensearch/gateway/remote/ClusterMetadataManifest.java
index 3a66419b1dc20..71815b6ee324c 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/ClusterMetadataManifest.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/ClusterMetadataManifest.java
@@ -44,6 +44,7 @@ public class ClusterMetadataManifest implements Writeable, ToXContentFragment {
     public static final int CODEC_V2 = 2; // In Codec V2, there are separate metadata files rather than a single global metadata file,
     // also we introduce index routing-metadata, diff and other attributes as part of manifest
     // required for state publication
+    public static final int CODEC_V3 = 3; // In Codec V3, we have introduced new diff field in diff-manifest's routing_table_diff
 
     private static final ParseField CLUSTER_TERM_FIELD = new ParseField("cluster_term");
     private static final ParseField STATE_VERSION_FIELD = new ParseField("state_version");
@@ -109,6 +110,10 @@ private static ClusterMetadataManifest.Builder manifestV2Builder(Object[] fields
             .clusterStateCustomMetadataMap(clusterStateCustomMetadata(fields));
     }
 
+    private static ClusterMetadataManifest.Builder manifestV3Builder(Object[] fields) {
+        return manifestV2Builder(fields);
+    }
+
     private static long term(Object[] fields) {
         return (long) fields[0];
     }
@@ -226,12 +231,18 @@ private static ClusterStateDiffManifest diffManifest(Object[] fields) {
         fields -> manifestV2Builder(fields).build()
     );
 
-    private static final ConstructingObjectParser<ClusterMetadataManifest, Void> CURRENT_PARSER = PARSER_V2;
+    private static final ConstructingObjectParser<ClusterMetadataManifest, Void> PARSER_V3 = new ConstructingObjectParser<>(
+        "cluster_metadata_manifest",
+        fields -> manifestV3Builder(fields).build()
+    );
+
+    private static final ConstructingObjectParser<ClusterMetadataManifest, Void> CURRENT_PARSER = PARSER_V3;
 
     static {
         declareParser(PARSER_V0, CODEC_V0);
         declareParser(PARSER_V1, CODEC_V1);
         declareParser(PARSER_V2, CODEC_V2);
+        declareParser(PARSER_V3, CODEC_V3);
     }
 
     private static void declareParser(ConstructingObjectParser<ClusterMetadataManifest, Void> parser, long codec_version) {
@@ -309,7 +320,7 @@ private static void declareParser(ConstructingObjectParser<ClusterMetadataManife
             );
             parser.declareObject(
                 ConstructingObjectParser.optionalConstructorArg(),
-                (p, c) -> ClusterStateDiffManifest.fromXContent(p),
+                (p, c) -> ClusterStateDiffManifest.fromXContent(p, codec_version),
                 DIFF_MANIFEST
             );
         }
diff --git a/server/src/main/java/org/opensearch/gateway/remote/ClusterStateDiffManifest.java b/server/src/main/java/org/opensearch/gateway/remote/ClusterStateDiffManifest.java
index aca53c92781e4..ab7fa1fddf4bf 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/ClusterStateDiffManifest.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/ClusterStateDiffManifest.java
@@ -32,8 +32,8 @@
 
 import static org.opensearch.cluster.DiffableUtils.NonDiffableValueSerializer.getAbstractInstance;
 import static org.opensearch.cluster.DiffableUtils.getStringKeySerializer;
-import static org.opensearch.cluster.routing.remote.RemoteRoutingTableService.CUSTOM_ROUTING_TABLE_VALUE_SERIALIZER;
 import static org.opensearch.core.xcontent.XContentParserUtils.ensureExpectedToken;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V3;
 
 /**
  * Manifest of diff between two cluster states
@@ -53,6 +53,7 @@ public class ClusterStateDiffManifest implements ToXContentFragment, Writeable {
     private static final String METADATA_CUSTOM_DIFF_FIELD = "metadata_custom_diff";
     private static final String UPSERTS_FIELD = "upserts";
     private static final String DELETES_FIELD = "deletes";
+    private static final String DIFF_FIELD = "diff";
     private static final String CLUSTER_BLOCKS_UPDATED_FIELD = "cluster_blocks_diff";
     private static final String DISCOVERY_NODES_UPDATED_FIELD = "discovery_nodes_diff";
     private static final String ROUTING_TABLE_DIFF = "routing_table_diff";
@@ -72,11 +73,17 @@ public class ClusterStateDiffManifest implements ToXContentFragment, Writeable {
     private final boolean discoveryNodesUpdated;
     private final List<String> indicesRoutingUpdated;
     private final List<String> indicesRoutingDeleted;
+    private String indicesRoutingDiffPath;
     private final boolean hashesOfConsistentSettingsUpdated;
     private final List<String> clusterStateCustomUpdated;
     private final List<String> clusterStateCustomDeleted;
 
-    public ClusterStateDiffManifest(ClusterState state, ClusterState previousState) {
+    public ClusterStateDiffManifest(
+        ClusterState state,
+        ClusterState previousState,
+        DiffableUtils.MapDiff<String, IndexRoutingTable, Map<String, IndexRoutingTable>> routingTableIncrementalDiff,
+        String indicesRoutingDiffPath
+    ) {
         fromStateUUID = previousState.stateUUID();
         toStateUUID = state.stateUUID();
         coordinationMetadataUpdated = !Metadata.isCoordinationMetadataEqual(state.metadata(), previousState.metadata());
@@ -103,17 +110,13 @@ public ClusterStateDiffManifest(ClusterState state, ClusterState previousState)
         customMetadataUpdated.addAll(customDiff.getUpserts().keySet());
         customMetadataDeleted = customDiff.getDeletes();
 
-        DiffableUtils.MapDiff<String, IndexRoutingTable, Map<String, IndexRoutingTable>> routingTableDiff = DiffableUtils.diff(
-            previousState.getRoutingTable().getIndicesRouting(),
-            state.getRoutingTable().getIndicesRouting(),
-            DiffableUtils.getStringKeySerializer(),
-            CUSTOM_ROUTING_TABLE_VALUE_SERIALIZER
-        );
-
         indicesRoutingUpdated = new ArrayList<>();
-        routingTableDiff.getUpserts().forEach((k, v) -> indicesRoutingUpdated.add(k));
-
-        indicesRoutingDeleted = routingTableDiff.getDeletes();
+        indicesRoutingDeleted = new ArrayList<>();
+        this.indicesRoutingDiffPath = indicesRoutingDiffPath;
+        if (routingTableIncrementalDiff != null) {
+            routingTableIncrementalDiff.getUpserts().forEach((k, v) -> indicesRoutingUpdated.add(k));
+            indicesRoutingDeleted.addAll(routingTableIncrementalDiff.getDeletes());
+        }
         hashesOfConsistentSettingsUpdated = !state.metadata()
             .hashesOfConsistentSettings()
             .equals(previousState.metadata().hashesOfConsistentSettings());
@@ -126,6 +129,7 @@ public ClusterStateDiffManifest(ClusterState state, ClusterState previousState)
         clusterStateCustomUpdated = new ArrayList<>(clusterStateCustomDiff.getDiffs().keySet());
         clusterStateCustomUpdated.addAll(clusterStateCustomDiff.getUpserts().keySet());
         clusterStateCustomDeleted = clusterStateCustomDiff.getDeletes();
+        List<String> indicie1s = indicesRoutingUpdated;
     }
 
     public ClusterStateDiffManifest(
@@ -143,6 +147,7 @@ public ClusterStateDiffManifest(
         boolean discoveryNodesUpdated,
         List<String> indicesRoutingUpdated,
         List<String> indicesRoutingDeleted,
+        String indicesRoutingDiffPath,
         boolean hashesOfConsistentSettingsUpdated,
         List<String> clusterStateCustomUpdated,
         List<String> clusterStateCustomDeleted
@@ -164,6 +169,7 @@ public ClusterStateDiffManifest(
         this.hashesOfConsistentSettingsUpdated = hashesOfConsistentSettingsUpdated;
         this.clusterStateCustomUpdated = Collections.unmodifiableList(clusterStateCustomUpdated);
         this.clusterStateCustomDeleted = Collections.unmodifiableList(clusterStateCustomDeleted);
+        this.indicesRoutingDiffPath = indicesRoutingDiffPath;
     }
 
     public ClusterStateDiffManifest(StreamInput in) throws IOException {
@@ -184,6 +190,7 @@ public ClusterStateDiffManifest(StreamInput in) throws IOException {
         this.hashesOfConsistentSettingsUpdated = in.readBoolean();
         this.clusterStateCustomUpdated = in.readStringList();
         this.clusterStateCustomDeleted = in.readStringList();
+        this.indicesRoutingDiffPath = in.readString();
     }
 
     @Override
@@ -237,6 +244,9 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
             builder.value(index);
         }
         builder.endArray();
+        if (indicesRoutingDiffPath != null) {
+            builder.field(DIFF_FIELD, indicesRoutingDiffPath);
+        }
         builder.endObject();
         builder.startObject(CLUSTER_STATE_CUSTOM_DIFF_FIELD);
         builder.startArray(UPSERTS_FIELD);
@@ -253,7 +263,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         return builder;
     }
 
-    public static ClusterStateDiffManifest fromXContent(XContentParser parser) throws IOException {
+    public static ClusterStateDiffManifest fromXContent(XContentParser parser, long codec_version) throws IOException {
         Builder builder = new Builder();
         if (parser.currentToken() == null) { // fresh parser? move to next token
             parser.nextToken();
@@ -341,6 +351,11 @@ public static ClusterStateDiffManifest fromXContent(XContentParser parser) throw
                             case DELETES_FIELD:
                                 builder.indicesRoutingDeleted(convertListToString(parser.listOrderedMap()));
                                 break;
+                            case DIFF_FIELD:
+                                if (codec_version >= CODEC_V3) {
+                                    builder.indicesRoutingDiffPath(parser.textOrNull());
+                                }
+                                break;
                             default:
                                 throw new XContentParseException("Unexpected field [" + currentFieldName + "]");
                         }
@@ -456,6 +471,10 @@ public List<String> getIndicesRoutingUpdated() {
         return indicesRoutingUpdated;
     }
 
+    public String getIndicesRoutingDiffPath() {
+        return indicesRoutingDiffPath;
+    }
+
     public List<String> getIndicesRoutingDeleted() {
         return indicesRoutingDeleted;
     }
@@ -468,6 +487,10 @@ public List<String> getClusterStateCustomDeleted() {
         return clusterStateCustomDeleted;
     }
 
+    public void setIndicesRoutingDiffPath(String indicesRoutingDiffPath) {
+        this.indicesRoutingDiffPath = indicesRoutingDiffPath;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
@@ -489,7 +512,8 @@ public boolean equals(Object o) {
             && Objects.equals(indicesRoutingUpdated, that.indicesRoutingUpdated)
             && Objects.equals(indicesRoutingDeleted, that.indicesRoutingDeleted)
             && Objects.equals(clusterStateCustomUpdated, that.clusterStateCustomUpdated)
-            && Objects.equals(clusterStateCustomDeleted, that.clusterStateCustomDeleted);
+            && Objects.equals(clusterStateCustomDeleted, that.clusterStateCustomDeleted)
+            && Objects.equals(indicesRoutingDiffPath, that.indicesRoutingDiffPath);
     }
 
     @Override
@@ -538,6 +562,7 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeBoolean(hashesOfConsistentSettingsUpdated);
         out.writeStringCollection(clusterStateCustomUpdated);
         out.writeStringCollection(clusterStateCustomDeleted);
+        out.writeString(indicesRoutingDiffPath);
     }
 
     /**
@@ -560,6 +585,7 @@ public static class Builder {
         private boolean discoveryNodesUpdated;
         private List<String> indicesRoutingUpdated;
         private List<String> indicesRoutingDeleted;
+        private String indicesRoutingDiff;
         private boolean hashesOfConsistentSettingsUpdated;
         private List<String> clusterStateCustomUpdated;
         private List<String> clusterStateCustomDeleted;
@@ -650,6 +676,11 @@ public Builder indicesRoutingDeleted(List<String> indicesRoutingDeleted) {
             return this;
         }
 
+        public Builder indicesRoutingDiffPath(String indicesRoutingDiffPath) {
+            this.indicesRoutingDiff = indicesRoutingDiffPath;
+            return this;
+        }
+
         public Builder clusterStateCustomUpdated(List<String> clusterStateCustomUpdated) {
             this.clusterStateCustomUpdated = clusterStateCustomUpdated;
             return this;
@@ -676,6 +707,7 @@ public ClusterStateDiffManifest build() {
                 discoveryNodesUpdated,
                 indicesRoutingUpdated,
                 indicesRoutingDeleted,
+                indicesRoutingDiff,
                 hashesOfConsistentSettingsUpdated,
                 clusterStateCustomUpdated,
                 clusterStateCustomDeleted
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateAttributesManager.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateAttributesManager.java
index 8f986423587d7..67ac8d2b9a810 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateAttributesManager.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateAttributesManager.java
@@ -8,13 +8,11 @@
 
 package org.opensearch.gateway.remote;
 
-import org.opensearch.action.LatchedActionListener;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.DiffableUtils;
 import org.opensearch.cluster.DiffableUtils.NonDiffableValueSerializer;
-import org.opensearch.common.CheckedRunnable;
 import org.opensearch.common.remote.AbstractRemoteWritableBlobEntity;
-import org.opensearch.common.remote.RemoteWritableEntityStore;
+import org.opensearch.common.remote.AbstractRemoteWritableEntityManager;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.gateway.remote.model.RemoteClusterBlocks;
@@ -26,9 +24,7 @@
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
 import org.opensearch.threadpool.ThreadPool;
 
-import java.io.IOException;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.Map;
 
 /**
@@ -36,13 +32,11 @@
  *
  * @opensearch.internal
  */
-public class RemoteClusterStateAttributesManager {
+public class RemoteClusterStateAttributesManager extends AbstractRemoteWritableEntityManager {
     public static final String CLUSTER_STATE_ATTRIBUTE = "cluster_state_attribute";
     public static final String DISCOVERY_NODES = "nodes";
     public static final String CLUSTER_BLOCKS = "blocks";
     public static final int CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION = 1;
-    private final Map<String, RemoteWritableEntityStore> remoteWritableEntityStores;
-    private final NamedWriteableRegistry namedWriteableRegistry;
 
     RemoteClusterStateAttributesManager(
         String clusterName,
@@ -51,8 +45,6 @@ public class RemoteClusterStateAttributesManager {
         NamedWriteableRegistry namedWriteableRegistry,
         ThreadPool threadpool
     ) {
-        this.namedWriteableRegistry = namedWriteableRegistry;
-        this.remoteWritableEntityStores = new HashMap<>();
         this.remoteWritableEntityStores.put(
             RemoteDiscoveryNodes.DISCOVERY_NODES,
             new RemoteClusterStateBlobStore<>(
@@ -85,46 +77,28 @@ public class RemoteClusterStateAttributesManager {
         );
     }
 
-    /**
-     * Allows async upload of Cluster State Attribute components to remote
-     */
-    CheckedRunnable<IOException> getAsyncMetadataWriteAction(
+    @Override
+    protected ActionListener<Void> getWrappedWriteListener(
         String component,
-        AbstractRemoteWritableBlobEntity blobEntity,
-        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
-    ) {
-        return () -> getStore(blobEntity).writeAsync(blobEntity, getActionListener(component, blobEntity, latchedActionListener));
-    }
-
-    private ActionListener<Void> getActionListener(
-        String component,
-        AbstractRemoteWritableBlobEntity remoteObject,
-        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
+        AbstractRemoteWritableBlobEntity remoteEntity,
+        ActionListener<ClusterMetadataManifest.UploadedMetadata> listener
     ) {
         return ActionListener.wrap(
-            resp -> latchedActionListener.onResponse(remoteObject.getUploadedMetadata()),
-            ex -> latchedActionListener.onFailure(new RemoteStateTransferException(component, remoteObject, ex))
+            resp -> listener.onResponse(remoteEntity.getUploadedMetadata()),
+            ex -> listener.onFailure(new RemoteStateTransferException("Upload failed for " + component, remoteEntity, ex))
         );
     }
 
-    private RemoteWritableEntityStore getStore(AbstractRemoteWritableBlobEntity entity) {
-        RemoteWritableEntityStore remoteStore = remoteWritableEntityStores.get(entity.getType());
-        if (remoteStore == null) {
-            throw new IllegalArgumentException("Unknown entity type [" + entity.getType() + "]");
-        }
-        return remoteStore;
-    }
-
-    public CheckedRunnable<IOException> getAsyncMetadataReadAction(
+    @Override
+    protected ActionListener<Object> getWrappedReadListener(
         String component,
-        AbstractRemoteWritableBlobEntity blobEntity,
-        LatchedActionListener<RemoteReadResult> listener
+        AbstractRemoteWritableBlobEntity remoteEntity,
+        ActionListener<RemoteReadResult> listener
     ) {
-        final ActionListener actionListener = ActionListener.wrap(
+        return ActionListener.wrap(
             response -> listener.onResponse(new RemoteReadResult(response, CLUSTER_STATE_ATTRIBUTE, component)),
-            listener::onFailure
+            ex -> listener.onFailure(new RemoteStateTransferException("Download failed for " + component, remoteEntity, ex))
         );
-        return () -> getStore(blobEntity).readAsync(blobEntity, actionListener);
     }
 
     public DiffableUtils.MapDiff<String, ClusterState.Custom, Map<String, ClusterState.Custom>> getUpdatedCustoms(
@@ -158,4 +132,5 @@ public DiffableUtils.MapDiff<String, ClusterState.Custom, Map<String, ClusterSta
             NonDiffableValueSerializer.getAbstractInstance()
         );
     }
+
 }
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManager.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManager.java
index 99235bc96bfe3..8691187c7fbfa 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManager.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManager.java
@@ -179,6 +179,7 @@ void deleteClusterMetadata(
             Set<String> staleGlobalMetadataPaths = new HashSet<>();
             Set<String> staleEphemeralAttributePaths = new HashSet<>();
             Set<String> staleIndexRoutingPaths = new HashSet<>();
+            Set<String> staleIndexRoutingDiffPaths = new HashSet<>();
             activeManifestBlobMetadata.forEach(blobMetadata -> {
                 ClusterMetadataManifest clusterMetadataManifest = remoteManifestManager.fetchRemoteClusterMetadataManifest(
                     clusterName,
@@ -222,6 +223,10 @@ void deleteClusterMetadata(
                     clusterMetadataManifest.getIndicesRouting()
                         .forEach(uploadedIndicesRouting -> filesToKeep.add(uploadedIndicesRouting.getUploadedFilename()));
                 }
+                if (clusterMetadataManifest.getDiffManifest() != null
+                    && clusterMetadataManifest.getDiffManifest().getIndicesRoutingDiffPath() != null) {
+                    filesToKeep.add(clusterMetadataManifest.getDiffManifest().getIndicesRoutingDiffPath());
+                }
             });
             staleManifestBlobMetadata.forEach(blobMetadata -> {
                 ClusterMetadataManifest clusterMetadataManifest = remoteManifestManager.fetchRemoteClusterMetadataManifest(
@@ -264,6 +269,18 @@ void deleteClusterMetadata(
                         }
                     });
                 }
+                if (clusterMetadataManifest.getDiffManifest() != null
+                    && clusterMetadataManifest.getDiffManifest().getIndicesRoutingDiffPath() != null) {
+                    if (!filesToKeep.contains(clusterMetadataManifest.getDiffManifest().getIndicesRoutingDiffPath())) {
+                        staleIndexRoutingDiffPaths.add(clusterMetadataManifest.getDiffManifest().getIndicesRoutingDiffPath());
+                        logger.debug(
+                            () -> new ParameterizedMessage(
+                                "Indices routing diff paths in stale manifest: {}",
+                                clusterMetadataManifest.getDiffManifest().getIndicesRoutingDiffPath()
+                            )
+                        );
+                    }
+                }
 
                 clusterMetadataManifest.getIndices().forEach(uploadedIndexMetadata -> {
                     String fileName = RemoteClusterStateUtils.getFormattedIndexFileName(uploadedIndexMetadata.getUploadedFilename());
@@ -316,6 +333,15 @@ void deleteClusterMetadata(
                 );
                 remoteStateStats.indexRoutingFilesCleanupAttemptFailed();
             }
+            try {
+                remoteRoutingTableService.deleteStaleIndexRoutingDiffPaths(new ArrayList<>(staleIndexRoutingDiffPaths));
+            } catch (IOException e) {
+                logger.error(
+                    () -> new ParameterizedMessage("Error while deleting stale index routing diff files {}", staleIndexRoutingDiffPaths),
+                    e
+                );
+                remoteStateStats.indicesRoutingDiffFileCleanupAttemptFailed();
+            }
         } catch (IllegalStateException e) {
             logger.error("Error while fetching Remote Cluster Metadata manifests", e);
         } catch (IOException e) {
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java
index 3e63f9114ea16..674279f2251bd 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java
@@ -14,6 +14,7 @@
 import org.opensearch.action.LatchedActionListener;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.Diff;
 import org.opensearch.cluster.DiffableUtils;
 import org.opensearch.cluster.block.ClusterBlocks;
 import org.opensearch.cluster.coordination.CoordinationMetadata;
@@ -26,11 +27,10 @@
 import org.opensearch.cluster.node.DiscoveryNodes.Builder;
 import org.opensearch.cluster.routing.IndexRoutingTable;
 import org.opensearch.cluster.routing.RoutingTable;
-import org.opensearch.cluster.routing.remote.InternalRemoteRoutingTableService;
+import org.opensearch.cluster.routing.RoutingTableIncrementalDiff;
 import org.opensearch.cluster.routing.remote.RemoteRoutingTableService;
 import org.opensearch.cluster.routing.remote.RemoteRoutingTableServiceFactory;
 import org.opensearch.cluster.service.ClusterService;
-import org.opensearch.common.CheckedRunnable;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.blobstore.BlobContainer;
 import org.opensearch.common.blobstore.BlobStore;
@@ -43,7 +43,6 @@
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
-import org.opensearch.core.index.Index;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedIndexMetadata;
 import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
@@ -59,6 +58,7 @@
 import org.opensearch.gateway.remote.model.RemoteReadResult;
 import org.opensearch.gateway.remote.model.RemoteTemplatesMetadata;
 import org.opensearch.gateway.remote.model.RemoteTransientSettingsMetadata;
+import org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff;
 import org.opensearch.index.translog.transfer.BlobStoreTransferService;
 import org.opensearch.node.Node;
 import org.opensearch.node.remotestore.RemoteStoreNodeAttribute;
@@ -98,7 +98,6 @@
 import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
 import static org.opensearch.gateway.remote.RemoteClusterStateUtils.UploadedMetadataResults;
 import static org.opensearch.gateway.remote.RemoteClusterStateUtils.clusterUUIDContainer;
-import static org.opensearch.gateway.remote.RemoteClusterStateUtils.getClusterMetadataBasePath;
 import static org.opensearch.gateway.remote.model.RemoteClusterStateCustoms.CLUSTER_STATE_CUSTOM;
 import static org.opensearch.gateway.remote.model.RemoteCoordinationMetadata.COORDINATION_METADATA;
 import static org.opensearch.gateway.remote.model.RemoteCustomMetadata.CUSTOM_DELIMITER;
@@ -107,6 +106,7 @@
 import static org.opensearch.gateway.remote.model.RemotePersistentSettingsMetadata.SETTING_METADATA;
 import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadata.TEMPLATES_METADATA;
 import static org.opensearch.gateway.remote.model.RemoteTransientSettingsMetadata.TRANSIENT_SETTING_METADATA;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_METADATA_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteStoreClusterStateEnabled;
 
 /**
@@ -146,7 +146,7 @@ public class RemoteClusterStateService implements Closeable {
     private final List<IndexMetadataUploadListener> indexMetadataUploadListeners;
     private BlobStoreRepository blobStoreRepository;
     private BlobStoreTransferService blobStoreTransferService;
-    private final RemoteRoutingTableService remoteRoutingTableService;
+    private RemoteRoutingTableService remoteRoutingTableService;
     private volatile TimeValue slowWriteLoggingThreshold;
 
     private final RemotePersistenceStats remoteStateStats;
@@ -197,16 +197,17 @@ public RemoteClusterStateService(
         this.remoteStateStats = new RemotePersistenceStats();
         this.namedWriteableRegistry = namedWriteableRegistry;
         this.indexMetadataUploadListeners = indexMetadataUploadListeners;
+        this.isPublicationEnabled = FeatureFlags.isEnabled(REMOTE_PUBLICATION_EXPERIMENTAL)
+            && RemoteStoreNodeAttribute.isRemoteStoreClusterStateEnabled(settings)
+            && RemoteStoreNodeAttribute.isRemoteRoutingTableEnabled(settings);
         this.remoteRoutingTableService = RemoteRoutingTableServiceFactory.getService(
             repositoriesService,
             settings,
             clusterSettings,
-            threadPool
+            threadpool,
+            ClusterName.CLUSTER_NAME_SETTING.get(settings).value()
         );
-        this.remoteClusterStateCleanupManager = new RemoteClusterStateCleanupManager(this, clusterService, remoteRoutingTableService);
-        this.isPublicationEnabled = FeatureFlags.isEnabled(REMOTE_PUBLICATION_EXPERIMENTAL)
-            && RemoteStoreNodeAttribute.isRemoteStoreClusterStateEnabled(settings)
-            && RemoteStoreNodeAttribute.isRemoteRoutingTableEnabled(settings);
+        remoteClusterStateCleanupManager = new RemoteClusterStateCleanupManager(this, clusterService, remoteRoutingTableService);
     }
 
     /**
@@ -236,13 +237,21 @@ public RemoteClusterStateManifestInfo writeFullMetadata(ClusterState clusterStat
             isPublicationEnabled,
             isPublicationEnabled ? clusterState.customs() : Collections.emptyMap(),
             isPublicationEnabled,
-            remoteRoutingTableService.getIndicesRouting(clusterState.getRoutingTable())
+            remoteRoutingTableService.getIndicesRouting(clusterState.getRoutingTable()),
+            null
+        );
+
+        ClusterStateDiffManifest clusterStateDiffManifest = new ClusterStateDiffManifest(
+            clusterState,
+            ClusterState.EMPTY_STATE,
+            null,
+            null
         );
         final RemoteClusterStateManifestInfo manifestDetails = remoteManifestManager.uploadManifest(
             clusterState,
             uploadedMetadataResults,
             previousClusterUUID,
-            new ClusterStateDiffManifest(clusterState, ClusterState.EMPTY_STATE),
+            clusterStateDiffManifest,
             false
         );
 
@@ -259,7 +268,7 @@ public RemoteClusterStateManifestInfo writeFullMetadata(ClusterState clusterStat
                 uploadedMetadataResults.uploadedIndicesRoutingMetadata.size()
             );
         } else {
-            logger.info(
+            logger.debug(
                 "writing cluster state took [{}ms]; " + "wrote full state with [{}] indices, [{}] indicesRouting and global metadata",
                 durationMillis,
                 uploadedMetadataResults.uploadedIndexMetadata.size(),
@@ -332,10 +341,13 @@ public RemoteClusterStateManifestInfo writeIncrementalMetadata(
             indicesToBeDeletedFromRemote.remove(indexMetadata.getIndex().getName());
         }
 
-        final DiffableUtils.MapDiff<String, IndexRoutingTable, Map<String, IndexRoutingTable>> routingTableDiff = remoteRoutingTableService
-            .getIndicesRoutingMapDiff(previousClusterState.getRoutingTable(), clusterState.getRoutingTable());
         final List<IndexRoutingTable> indicesRoutingToUpload = new ArrayList<>();
-        routingTableDiff.getUpserts().forEach((k, v) -> indicesRoutingToUpload.add(v));
+        final DiffableUtils.MapDiff<String, IndexRoutingTable, Map<String, IndexRoutingTable>> routingTableIncrementalDiff =
+            remoteRoutingTableService.getIndicesRoutingMapDiff(previousClusterState.getRoutingTable(), clusterState.getRoutingTable());
+
+        Map<String, Diff<IndexRoutingTable>> indexRoutingTableDiffs = routingTableIncrementalDiff.getDiffs();
+        routingTableIncrementalDiff.getDiffs().forEach((k, v) -> indicesRoutingToUpload.add(clusterState.getRoutingTable().index(k)));
+        routingTableIncrementalDiff.getUpserts().forEach((k, v) -> indicesRoutingToUpload.add(v));
 
         UploadedMetadataResults uploadedMetadataResults;
         // For migration case from codec V0 or V1 to V2, we have added null check on metadata attribute files,
@@ -371,7 +383,8 @@ public RemoteClusterStateManifestInfo writeIncrementalMetadata(
             updateTransientSettingsMetadata,
             clusterStateCustomsDiff.getUpserts(),
             updateHashesOfConsistentSettings,
-            indicesRoutingToUpload
+            indicesRoutingToUpload,
+            indexRoutingTableDiffs
         );
 
         // update the map if the metadata was uploaded
@@ -413,14 +426,23 @@ public RemoteClusterStateManifestInfo writeIncrementalMetadata(
         uploadedMetadataResults.uploadedIndicesRoutingMetadata = remoteRoutingTableService.getAllUploadedIndicesRouting(
             previousManifest,
             uploadedMetadataResults.uploadedIndicesRoutingMetadata,
-            routingTableDiff.getDeletes()
+            routingTableIncrementalDiff.getDeletes()
+        );
+
+        ClusterStateDiffManifest clusterStateDiffManifest = new ClusterStateDiffManifest(
+            clusterState,
+            previousClusterState,
+            routingTableIncrementalDiff,
+            uploadedMetadataResults.uploadedIndicesRoutingDiffMetadata != null
+                ? uploadedMetadataResults.uploadedIndicesRoutingDiffMetadata.getUploadedFilename()
+                : null
         );
 
         final RemoteClusterStateManifestInfo manifestDetails = remoteManifestManager.uploadManifest(
             clusterState,
             uploadedMetadataResults,
             previousManifest.getPreviousClusterUUID(),
-            new ClusterStateDiffManifest(clusterState, previousClusterState),
+            clusterStateDiffManifest,
             false
         );
 
@@ -458,8 +480,8 @@ public RemoteClusterStateManifestInfo writeIncrementalMetadata(
                 customsDiff.getUpserts().size()
             );
         } else {
-            logger.info("{}; {}", clusterStateUploadTimeMessage, metadataUpdateMessage);
-            logger.info(
+            logger.debug("{}; {}", clusterStateUploadTimeMessage, metadataUpdateMessage);
+            logger.debug(
                 "writing cluster state for version [{}] took [{}ms]; "
                     + "wrote metadata for [{}] indices and skipped [{}] unchanged indices, coordination metadata updated : [{}], "
                     + "settings metadata updated : [{}], templates metadata updated : [{}], custom metadata updated : [{}]",
@@ -490,15 +512,17 @@ UploadedMetadataResults writeMetadataInParallel(
         boolean uploadTransientSettingMetadata,
         Map<String, ClusterState.Custom> clusterStateCustomToUpload,
         boolean uploadHashesOfConsistentSettings,
-        List<IndexRoutingTable> indicesRoutingToUpload
+        List<IndexRoutingTable> indicesRoutingToUpload,
+        Map<String, Diff<IndexRoutingTable>> indexRoutingTableDiff
     ) throws IOException {
         assert Objects.nonNull(indexMetadataUploadListeners) : "indexMetadataUploadListeners can not be null";
         int totalUploadTasks = indexToUpload.size() + indexMetadataUploadListeners.size() + customToUpload.size()
             + (uploadCoordinationMetadata ? 1 : 0) + (uploadSettingsMetadata ? 1 : 0) + (uploadTemplateMetadata ? 1 : 0)
             + (uploadDiscoveryNodes ? 1 : 0) + (uploadClusterBlock ? 1 : 0) + (uploadTransientSettingMetadata ? 1 : 0)
-            + clusterStateCustomToUpload.size() + (uploadHashesOfConsistentSettings ? 1 : 0) + indicesRoutingToUpload.size();
+            + clusterStateCustomToUpload.size() + (uploadHashesOfConsistentSettings ? 1 : 0) + indicesRoutingToUpload.size()
+            + (indexRoutingTableDiff != null && !indexRoutingTableDiff.isEmpty() ? 1 : 0);
         CountDownLatch latch = new CountDownLatch(totalUploadTasks);
-        Map<String, CheckedRunnable<IOException>> uploadTasks = new ConcurrentHashMap<>(totalUploadTasks);
+        List<String> uploadTasks = Collections.synchronizedList(new ArrayList<>(totalUploadTasks));
         Map<String, ClusterMetadataManifest.UploadedMetadata> results = new ConcurrentHashMap<>(totalUploadTasks);
         List<Exception> exceptionList = Collections.synchronizedList(new ArrayList<>(totalUploadTasks));
 
@@ -517,169 +541,164 @@ UploadedMetadataResults writeMetadataInParallel(
         );
 
         if (uploadSettingsMetadata) {
-            uploadTasks.put(
+            uploadTasks.add(SETTING_METADATA);
+            remoteGlobalMetadataManager.writeAsync(
                 SETTING_METADATA,
-                remoteGlobalMetadataManager.getAsyncMetadataWriteAction(
-                    new RemotePersistentSettingsMetadata(
-                        clusterState.metadata().persistentSettings(),
-                        clusterState.metadata().version(),
-                        clusterState.metadata().clusterUUID(),
-                        blobStoreRepository.getCompressor(),
-                        blobStoreRepository.getNamedXContentRegistry()
-                    ),
-                    listener
-                )
+                new RemotePersistentSettingsMetadata(
+                    clusterState.metadata().persistentSettings(),
+                    clusterState.metadata().version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
             );
         }
         if (uploadTransientSettingMetadata) {
-            uploadTasks.put(
+            uploadTasks.add(TRANSIENT_SETTING_METADATA);
+            remoteGlobalMetadataManager.writeAsync(
                 TRANSIENT_SETTING_METADATA,
-                remoteGlobalMetadataManager.getAsyncMetadataWriteAction(
-                    new RemoteTransientSettingsMetadata(
-                        clusterState.metadata().transientSettings(),
-                        clusterState.metadata().version(),
-                        clusterState.metadata().clusterUUID(),
-                        blobStoreRepository.getCompressor(),
-                        blobStoreRepository.getNamedXContentRegistry()
-                    ),
-                    listener
-                )
+                new RemoteTransientSettingsMetadata(
+                    clusterState.metadata().transientSettings(),
+                    clusterState.metadata().version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
             );
         }
         if (uploadCoordinationMetadata) {
-            uploadTasks.put(
+            uploadTasks.add(COORDINATION_METADATA);
+            remoteGlobalMetadataManager.writeAsync(
                 COORDINATION_METADATA,
-                remoteGlobalMetadataManager.getAsyncMetadataWriteAction(
-                    new RemoteCoordinationMetadata(
-                        clusterState.metadata().coordinationMetadata(),
-                        clusterState.metadata().version(),
-                        clusterState.metadata().clusterUUID(),
-                        blobStoreRepository.getCompressor(),
-                        blobStoreRepository.getNamedXContentRegistry()
-                    ),
-                    listener
-                )
+                new RemoteCoordinationMetadata(
+                    clusterState.metadata().coordinationMetadata(),
+                    clusterState.metadata().version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
             );
         }
         if (uploadTemplateMetadata) {
-            uploadTasks.put(
+            uploadTasks.add(TEMPLATES_METADATA);
+            remoteGlobalMetadataManager.writeAsync(
                 TEMPLATES_METADATA,
-                remoteGlobalMetadataManager.getAsyncMetadataWriteAction(
-                    new RemoteTemplatesMetadata(
-                        clusterState.metadata().templatesMetadata(),
-                        clusterState.metadata().version(),
-                        clusterState.metadata().clusterUUID(),
-                        blobStoreRepository.getCompressor(),
-                        blobStoreRepository.getNamedXContentRegistry()
-                    ),
-                    listener
-                )
+                new RemoteTemplatesMetadata(
+                    clusterState.metadata().templatesMetadata(),
+                    clusterState.metadata().version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
             );
         }
         if (uploadDiscoveryNodes) {
-            uploadTasks.put(
-                DISCOVERY_NODES,
-                remoteClusterStateAttributesManager.getAsyncMetadataWriteAction(
-                    RemoteDiscoveryNodes.DISCOVERY_NODES,
-                    new RemoteDiscoveryNodes(
-                        clusterState.nodes(),
-                        clusterState.version(),
-                        clusterState.stateUUID(),
-                        blobStoreRepository.getCompressor()
-                    ),
-                    listener
-                )
+            uploadTasks.add(DISCOVERY_NODES);
+            remoteClusterStateAttributesManager.writeAsync(
+                RemoteDiscoveryNodes.DISCOVERY_NODES,
+                new RemoteDiscoveryNodes(
+                    clusterState.nodes(),
+                    clusterState.version(),
+                    clusterState.stateUUID(),
+                    blobStoreRepository.getCompressor()
+                ),
+                listener
             );
         }
         if (uploadClusterBlock) {
-            uploadTasks.put(
-                CLUSTER_BLOCKS,
-                remoteClusterStateAttributesManager.getAsyncMetadataWriteAction(
-                    RemoteClusterBlocks.CLUSTER_BLOCKS,
-                    new RemoteClusterBlocks(
-                        clusterState.blocks(),
-                        clusterState.version(),
-                        clusterState.metadata().clusterUUID(),
-                        blobStoreRepository.getCompressor()
-                    ),
-                    listener
-                )
+            uploadTasks.add(CLUSTER_BLOCKS);
+            remoteClusterStateAttributesManager.writeAsync(
+                RemoteClusterBlocks.CLUSTER_BLOCKS,
+                new RemoteClusterBlocks(
+                    clusterState.blocks(),
+                    clusterState.version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor()
+                ),
+                listener
             );
         }
         if (uploadHashesOfConsistentSettings) {
-            uploadTasks.put(
+            uploadTasks.add(HASHES_OF_CONSISTENT_SETTINGS);
+            remoteGlobalMetadataManager.writeAsync(
                 HASHES_OF_CONSISTENT_SETTINGS,
-                remoteGlobalMetadataManager.getAsyncMetadataWriteAction(
-                    new RemoteHashesOfConsistentSettings(
-                        (DiffableStringMap) clusterState.metadata().hashesOfConsistentSettings(),
-                        clusterState.metadata().version(),
-                        clusterState.metadata().clusterUUID(),
-                        blobStoreRepository.getCompressor()
-                    ),
-                    listener
-                )
+                new RemoteHashesOfConsistentSettings(
+                    (DiffableStringMap) clusterState.metadata().hashesOfConsistentSettings(),
+                    clusterState.metadata().version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor()
+                ),
+                listener
             );
         }
         customToUpload.forEach((key, value) -> {
             String customComponent = String.join(CUSTOM_DELIMITER, CUSTOM_METADATA, key);
-            uploadTasks.put(
+            uploadTasks.add(customComponent);
+            remoteGlobalMetadataManager.writeAsync(
                 customComponent,
-                remoteGlobalMetadataManager.getAsyncMetadataWriteAction(
-                    new RemoteCustomMetadata(
-                        value,
-                        key,
-                        clusterState.metadata().version(),
-                        clusterState.metadata().clusterUUID(),
-                        blobStoreRepository.getCompressor(),
-                        namedWriteableRegistry
-                    ),
-                    listener
-                )
+                new RemoteCustomMetadata(
+                    value,
+                    key,
+                    clusterState.metadata().version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor(),
+                    namedWriteableRegistry
+                ),
+                listener
             );
         });
         indexToUpload.forEach(indexMetadata -> {
-            uploadTasks.put(
+            uploadTasks.add(indexMetadata.getIndex().getName());
+            remoteIndexMetadataManager.writeAsync(
                 indexMetadata.getIndex().getName(),
-                remoteIndexMetadataManager.getAsyncIndexMetadataWriteAction(indexMetadata, clusterState.metadata().clusterUUID(), listener)
+                new RemoteIndexMetadata(
+                    indexMetadata,
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
             );
         });
 
         clusterStateCustomToUpload.forEach((key, value) -> {
-            uploadTasks.put(
-                key,
-                remoteClusterStateAttributesManager.getAsyncMetadataWriteAction(
-                    CLUSTER_STATE_CUSTOM,
-                    new RemoteClusterStateCustoms(
-                        value,
-                        key,
-                        clusterState.version(),
-                        clusterState.metadata().clusterUUID(),
-                        blobStoreRepository.getCompressor(),
-                        namedWriteableRegistry
-                    ),
-                    listener
-                )
+            uploadTasks.add(key);
+            remoteClusterStateAttributesManager.writeAsync(
+                CLUSTER_STATE_CUSTOM,
+                new RemoteClusterStateCustoms(
+                    value,
+                    key,
+                    clusterState.version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor(),
+                    namedWriteableRegistry
+                ),
+                listener
             );
         });
         indicesRoutingToUpload.forEach(indexRoutingTable -> {
-            uploadTasks.put(
-                InternalRemoteRoutingTableService.INDEX_ROUTING_METADATA_PREFIX + indexRoutingTable.getIndex().getName(),
-                remoteRoutingTableService.getIndexRoutingAsyncAction(
-                    clusterState,
-                    indexRoutingTable,
-                    listener,
-                    getClusterMetadataBasePath(
-                        blobStoreRepository,
-                        clusterState.getClusterName().value(),
-                        clusterState.metadata().clusterUUID()
-                    )
-                )
+            uploadTasks.add(INDEX_ROUTING_METADATA_PREFIX + indexRoutingTable.getIndex().getName());
+            remoteRoutingTableService.getAsyncIndexRoutingWriteAction(
+                clusterState.metadata().clusterUUID(),
+                clusterState.term(),
+                clusterState.version(),
+                indexRoutingTable,
+                listener
             );
         });
-
-        // start async upload of all required metadata files
-        for (CheckedRunnable<IOException> uploadTask : uploadTasks.values()) {
-            uploadTask.run();
+        if (indexRoutingTableDiff != null && !indexRoutingTableDiff.isEmpty()) {
+            uploadTasks.add(RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_FILE);
+            remoteRoutingTableService.getAsyncIndexRoutingDiffWriteAction(
+                clusterState.metadata().clusterUUID(),
+                clusterState.term(),
+                clusterState.version(),
+                indexRoutingTableDiff,
+                listener
+            );
         }
         invokeIndexMetadataUploadListeners(indexToUpload, prevIndexMetadataByName, latch, exceptionList);
 
@@ -690,7 +709,7 @@ UploadedMetadataResults writeMetadataInParallel(
                     String.format(
                         Locale.ROOT,
                         "Timed out waiting for transfer of following metadata to complete - %s",
-                        String.join(", ", uploadTasks.keySet())
+                        String.join(", ", uploadTasks)
                     )
                 );
                 exceptionList.forEach(ex::addSuppressed);
@@ -699,11 +718,7 @@ UploadedMetadataResults writeMetadataInParallel(
         } catch (InterruptedException ex) {
             exceptionList.forEach(ex::addSuppressed);
             RemoteStateTransferException exception = new RemoteStateTransferException(
-                String.format(
-                    Locale.ROOT,
-                    "Timed out waiting for transfer of metadata to complete - %s",
-                    String.join(", ", uploadTasks.keySet())
-                ),
+                String.format(Locale.ROOT, "Timed out waiting for transfer of metadata to complete - %s", String.join(", ", uploadTasks)),
                 ex
             );
             Thread.currentThread().interrupt();
@@ -711,20 +726,28 @@ UploadedMetadataResults writeMetadataInParallel(
         }
         if (!exceptionList.isEmpty()) {
             RemoteStateTransferException exception = new RemoteStateTransferException(
+                String.format(Locale.ROOT, "Exception during transfer of following metadata to Remote - %s", String.join(", ", uploadTasks))
+            );
+            exceptionList.forEach(exception::addSuppressed);
+            throw exception;
+        }
+        if (results.size() != uploadTasks.size()) {
+            throw new RemoteStateTransferException(
                 String.format(
                     Locale.ROOT,
-                    "Exception during transfer of following metadata to Remote - %s",
-                    String.join(", ", uploadTasks.keySet())
+                    "Some metadata components were not uploaded successfully. Objects to be uploaded: %s, uploaded objects: %s",
+                    String.join(", ", uploadTasks),
+                    String.join(", ", results.keySet())
                 )
             );
-            exceptionList.forEach(exception::addSuppressed);
-            throw exception;
         }
         UploadedMetadataResults response = new UploadedMetadataResults();
         results.forEach((name, uploadedMetadata) -> {
             if (uploadedMetadata.getClass().equals(UploadedIndexMetadata.class)
-                && uploadedMetadata.getComponent().contains(InternalRemoteRoutingTableService.INDEX_ROUTING_METADATA_PREFIX)) {
+                && uploadedMetadata.getComponent().contains(INDEX_ROUTING_METADATA_PREFIX)) {
                 response.uploadedIndicesRoutingMetadata.add((UploadedIndexMetadata) uploadedMetadata);
+            } else if (RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_FILE.equals(name)) {
+                response.uploadedIndicesRoutingDiffMetadata = (UploadedMetadataAttribute) uploadedMetadata;
             } else if (name.startsWith(CUSTOM_METADATA)) {
                 // component name for custom metadata will look like custom--<metadata-attribute>
                 String custom = name.split(DELIMITER)[0].split(CUSTOM_DELIMITER)[1];
@@ -897,9 +920,8 @@ public void start() {
         final Repository repository = repositoriesService.get().repository(remoteStoreRepo);
         assert repository instanceof BlobStoreRepository : "Repository should be instance of BlobStoreRepository";
         blobStoreRepository = (BlobStoreRepository) repository;
-        this.remoteRoutingTableService.start();
-        blobStoreTransferService = new BlobStoreTransferService(getBlobStore(), threadpool);
         String clusterName = ClusterName.CLUSTER_NAME_SETTING.get(settings).value();
+        blobStoreTransferService = new BlobStoreTransferService(getBlobStore(), threadpool);
 
         remoteGlobalMetadataManager = new RemoteGlobalMetadataManager(
             clusterSettings,
@@ -931,6 +953,8 @@ public void start() {
             namedWriteableRegistry,
             threadpool
         );
+
+        remoteRoutingTableService.start();
         remoteClusterStateCleanupManager.start();
     }
 
@@ -993,17 +1017,18 @@ ClusterState readClusterStateInParallel(
         List<UploadedIndexMetadata> indicesRoutingToRead,
         boolean readHashesOfConsistentSettings,
         Map<String, UploadedMetadataAttribute> clusterStateCustomToRead,
+        boolean readIndexRoutingTableDiff,
         boolean includeEphemeral
     ) throws IOException {
         int totalReadTasks = indicesToRead.size() + customToRead.size() + (readCoordinationMetadata ? 1 : 0) + (readSettingsMetadata
             ? 1
             : 0) + (readTemplatesMetadata ? 1 : 0) + (readDiscoveryNodes ? 1 : 0) + (readClusterBlocks ? 1 : 0)
             + (readTransientSettingsMetadata ? 1 : 0) + (readHashesOfConsistentSettings ? 1 : 0) + clusterStateCustomToRead.size()
-            + indicesRoutingToRead.size();
+            + indicesRoutingToRead.size() + (readIndexRoutingTableDiff ? 1 : 0);
         CountDownLatch latch = new CountDownLatch(totalReadTasks);
-        List<CheckedRunnable<IOException>> asyncMetadataReadActions = new ArrayList<>();
         List<RemoteReadResult> readResults = Collections.synchronizedList(new ArrayList<>());
         List<IndexRoutingTable> readIndexRoutingTableResults = Collections.synchronizedList(new ArrayList<>());
+        AtomicReference<RoutingTableIncrementalDiff> readIndexRoutingTableDiffResults = new AtomicReference<>();
         List<Exception> exceptionList = Collections.synchronizedList(new ArrayList<>(totalReadTasks));
 
         LatchedActionListener<RemoteReadResult> listener = new LatchedActionListener<>(ActionListener.wrap(response -> {
@@ -1015,171 +1040,173 @@ ClusterState readClusterStateInParallel(
         }), latch);
 
         for (UploadedIndexMetadata indexMetadata : indicesToRead) {
-            asyncMetadataReadActions.add(
-                remoteIndexMetadataManager.getAsyncIndexMetadataReadAction(clusterUUID, indexMetadata.getUploadedFilename(), listener)
+            remoteIndexMetadataManager.readAsync(
+                indexMetadata.getIndexName(),
+                new RemoteIndexMetadata(
+                    RemoteClusterStateUtils.getFormattedIndexFileName(indexMetadata.getUploadedFilename()),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
             );
         }
 
         LatchedActionListener<IndexRoutingTable> routingTableLatchedActionListener = new LatchedActionListener<>(
             ActionListener.wrap(response -> {
-                logger.debug("Successfully read cluster state component from remote");
+                logger.debug(() -> new ParameterizedMessage("Successfully read index-routing for index {}", response.getIndex().getName()));
                 readIndexRoutingTableResults.add(response);
             }, ex -> {
-                logger.error("Failed to read cluster state from remote", ex);
+                logger.error(() -> new ParameterizedMessage("Failed to read index-routing from remote"), ex);
                 exceptionList.add(ex);
             }),
             latch
         );
 
         for (UploadedIndexMetadata indexRouting : indicesRoutingToRead) {
-            asyncMetadataReadActions.add(
-                remoteRoutingTableService.getAsyncIndexRoutingReadAction(
-                    indexRouting.getUploadedFilename(),
-                    new Index(indexRouting.getIndexName(), indexRouting.getIndexUUID()),
-                    routingTableLatchedActionListener
-                )
+            remoteRoutingTableService.getAsyncIndexRoutingReadAction(
+                clusterUUID,
+                indexRouting.getUploadedFilename(),
+                routingTableLatchedActionListener
+            );
+        }
+
+        LatchedActionListener<RoutingTableIncrementalDiff> routingTableDiffLatchedActionListener = new LatchedActionListener<>(
+            ActionListener.wrap(response -> {
+                logger.debug("Successfully read routing table diff component from remote");
+                readIndexRoutingTableDiffResults.set(response);
+            }, ex -> {
+                logger.error("Failed to read routing table diff from remote", ex);
+                exceptionList.add(ex);
+            }),
+            latch
+        );
+
+        if (readIndexRoutingTableDiff) {
+            remoteRoutingTableService.getAsyncIndexRoutingTableDiffReadAction(
+                clusterUUID,
+                manifest.getDiffManifest().getIndicesRoutingDiffPath(),
+                routingTableDiffLatchedActionListener
             );
         }
 
         for (Map.Entry<String, UploadedMetadataAttribute> entry : customToRead.entrySet()) {
-            asyncMetadataReadActions.add(
-                remoteGlobalMetadataManager.getAsyncMetadataReadAction(
-                    new RemoteCustomMetadata(
-                        entry.getValue().getUploadedFilename(),
-                        entry.getKey(),
-                        clusterUUID,
-                        blobStoreRepository.getCompressor(),
-                        namedWriteableRegistry
-                    ),
-                    entry.getValue().getAttributeName(),
-                    listener
-                )
+            remoteGlobalMetadataManager.readAsync(
+                entry.getValue().getAttributeName(),
+                new RemoteCustomMetadata(
+                    entry.getValue().getUploadedFilename(),
+                    entry.getKey(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor(),
+                    namedWriteableRegistry
+                ),
+                listener
             );
         }
 
         if (readCoordinationMetadata) {
-            asyncMetadataReadActions.add(
-                remoteGlobalMetadataManager.getAsyncMetadataReadAction(
-                    new RemoteCoordinationMetadata(
-                        manifest.getCoordinationMetadata().getUploadedFilename(),
-                        clusterUUID,
-                        blobStoreRepository.getCompressor(),
-                        blobStoreRepository.getNamedXContentRegistry()
-                    ),
-                    COORDINATION_METADATA,
-                    listener
-                )
+            remoteGlobalMetadataManager.readAsync(
+                COORDINATION_METADATA,
+                new RemoteCoordinationMetadata(
+                    manifest.getCoordinationMetadata().getUploadedFilename(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
             );
         }
 
         if (readSettingsMetadata) {
-            asyncMetadataReadActions.add(
-                remoteGlobalMetadataManager.getAsyncMetadataReadAction(
-                    new RemotePersistentSettingsMetadata(
-                        manifest.getSettingsMetadata().getUploadedFilename(),
-                        clusterUUID,
-                        blobStoreRepository.getCompressor(),
-                        blobStoreRepository.getNamedXContentRegistry()
-                    ),
-                    SETTING_METADATA,
-                    listener
-                )
+            remoteGlobalMetadataManager.readAsync(
+                SETTING_METADATA,
+                new RemotePersistentSettingsMetadata(
+                    manifest.getSettingsMetadata().getUploadedFilename(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
             );
         }
 
         if (readTransientSettingsMetadata) {
-            asyncMetadataReadActions.add(
-                remoteGlobalMetadataManager.getAsyncMetadataReadAction(
-                    new RemoteTransientSettingsMetadata(
-                        manifest.getTransientSettingsMetadata().getUploadedFilename(),
-                        clusterUUID,
-                        blobStoreRepository.getCompressor(),
-                        blobStoreRepository.getNamedXContentRegistry()
-                    ),
-                    TRANSIENT_SETTING_METADATA,
-                    listener
-                )
+            remoteGlobalMetadataManager.readAsync(
+                TRANSIENT_SETTING_METADATA,
+                new RemoteTransientSettingsMetadata(
+                    manifest.getTransientSettingsMetadata().getUploadedFilename(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
             );
         }
 
         if (readTemplatesMetadata) {
-            asyncMetadataReadActions.add(
-                remoteGlobalMetadataManager.getAsyncMetadataReadAction(
-                    new RemoteTemplatesMetadata(
-                        manifest.getTemplatesMetadata().getUploadedFilename(),
-                        clusterUUID,
-                        blobStoreRepository.getCompressor(),
-                        blobStoreRepository.getNamedXContentRegistry()
-                    ),
-                    TEMPLATES_METADATA,
-                    listener
-                )
+            remoteGlobalMetadataManager.readAsync(
+                TEMPLATES_METADATA,
+                new RemoteTemplatesMetadata(
+                    manifest.getTemplatesMetadata().getUploadedFilename(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
             );
         }
 
         if (readDiscoveryNodes) {
-            asyncMetadataReadActions.add(
-                remoteClusterStateAttributesManager.getAsyncMetadataReadAction(
-                    DISCOVERY_NODES,
-                    new RemoteDiscoveryNodes(
-                        manifest.getDiscoveryNodesMetadata().getUploadedFilename(),
-                        clusterUUID,
-                        blobStoreRepository.getCompressor()
-                    ),
-                    listener
-                )
+            remoteClusterStateAttributesManager.readAsync(
+                DISCOVERY_NODES,
+                new RemoteDiscoveryNodes(
+                    manifest.getDiscoveryNodesMetadata().getUploadedFilename(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor()
+                ),
+                listener
             );
         }
 
         if (readClusterBlocks) {
-            asyncMetadataReadActions.add(
-                remoteClusterStateAttributesManager.getAsyncMetadataReadAction(
-                    CLUSTER_BLOCKS,
-                    new RemoteClusterBlocks(
-                        manifest.getClusterBlocksMetadata().getUploadedFilename(),
-                        clusterUUID,
-                        blobStoreRepository.getCompressor()
-                    ),
-                    listener
-                )
+            remoteClusterStateAttributesManager.readAsync(
+                CLUSTER_BLOCKS,
+                new RemoteClusterBlocks(
+                    manifest.getClusterBlocksMetadata().getUploadedFilename(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor()
+                ),
+                listener
             );
         }
 
         if (readHashesOfConsistentSettings) {
-            asyncMetadataReadActions.add(
-                remoteGlobalMetadataManager.getAsyncMetadataReadAction(
-                    new RemoteHashesOfConsistentSettings(
-                        manifest.getHashesOfConsistentSettings().getUploadedFilename(),
-                        clusterUUID,
-                        blobStoreRepository.getCompressor()
-                    ),
-                    HASHES_OF_CONSISTENT_SETTINGS,
-                    listener
-                )
+            remoteGlobalMetadataManager.readAsync(
+                HASHES_OF_CONSISTENT_SETTINGS,
+                new RemoteHashesOfConsistentSettings(
+                    manifest.getHashesOfConsistentSettings().getUploadedFilename(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor()
+                ),
+                listener
             );
         }
 
         for (Map.Entry<String, UploadedMetadataAttribute> entry : clusterStateCustomToRead.entrySet()) {
-            asyncMetadataReadActions.add(
-                remoteClusterStateAttributesManager.getAsyncMetadataReadAction(
-                    // pass component name as cluster-state-custom--<custom_name>, so that we can interpret it later
-                    String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, entry.getKey()),
-                    new RemoteClusterStateCustoms(
-                        entry.getValue().getUploadedFilename(),
-                        entry.getValue().getAttributeName(),
-                        clusterUUID,
-                        blobStoreRepository.getCompressor(),
-                        namedWriteableRegistry
-                    ),
-                    listener
-                )
+            remoteClusterStateAttributesManager.readAsync(
+                // pass component name as cluster-state-custom--<custom_name>, so that we can interpret it later
+                String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, entry.getKey()),
+                new RemoteClusterStateCustoms(
+                    entry.getValue().getUploadedFilename(),
+                    entry.getValue().getAttributeName(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor(),
+                    namedWriteableRegistry
+                ),
+                listener
             );
         }
 
-        for (CheckedRunnable<IOException> asyncMetadataReadAction : asyncMetadataReadActions) {
-            asyncMetadataReadAction.run();
-        }
-
         try {
             if (latch.await(this.remoteStateReadTimeout.getMillis(), TimeUnit.MILLISECONDS) == false) {
                 RemoteStateTransferException exception = new RemoteStateTransferException(
@@ -1265,6 +1292,14 @@ ClusterState readClusterStateInParallel(
         readIndexRoutingTableResults.forEach(
             indexRoutingTable -> indicesRouting.put(indexRoutingTable.getIndex().getName(), indexRoutingTable)
         );
+        RoutingTableIncrementalDiff routingTableDiff = readIndexRoutingTableDiffResults.get();
+        if (routingTableDiff != null) {
+            routingTableDiff.getDiffs().forEach((key, diff) -> {
+                IndexRoutingTable previousIndexRoutingTable = indicesRouting.get(key);
+                IndexRoutingTable updatedTable = diff.apply(previousIndexRoutingTable);
+                indicesRouting.put(key, updatedTable);
+            });
+        }
         clusterStateBuilder.routingTable(new RoutingTable(manifest.getRoutingTableVersion(), indicesRouting));
 
         return clusterStateBuilder.build();
@@ -1293,6 +1328,7 @@ public ClusterState getClusterStateForManifest(
                 includeEphemeral ? manifest.getIndicesRouting() : emptyList(),
                 includeEphemeral && manifest.getHashesOfConsistentSettings() != null,
                 includeEphemeral ? manifest.getClusterStateCustomMap() : emptyMap(),
+                false,
                 includeEphemeral
             );
         } else {
@@ -1313,6 +1349,7 @@ public ClusterState getClusterStateForManifest(
                 emptyList(),
                 false,
                 emptyMap(),
+                false,
                 false
             );
             Metadata.Builder mb = Metadata.builder(remoteGlobalMetadataManager.getGlobalMetadata(manifest.getClusterUUID(), manifest));
@@ -1369,6 +1406,9 @@ public ClusterState getClusterStateUsingDiff(ClusterMetadataManifest manifest, C
             updatedIndexRouting,
             diff.isHashesOfConsistentSettingsUpdated(),
             updatedClusterStateCustom,
+            manifest.getDiffManifest() != null
+                && manifest.getDiffManifest().getIndicesRoutingDiffPath() != null
+                && !manifest.getDiffManifest().getIndicesRoutingDiffPath().isEmpty(),
             true
         );
         ClusterState.Builder clusterStateBuilder = ClusterState.builder(updatedClusterState);
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateUtils.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateUtils.java
index f2b93c3784407..74cb838286961 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateUtils.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateUtils.java
@@ -88,6 +88,7 @@ public static class UploadedMetadataResults {
         ClusterMetadataManifest.UploadedMetadataAttribute uploadedClusterBlocks;
         List<ClusterMetadataManifest.UploadedIndexMetadata> uploadedIndicesRoutingMetadata;
         ClusterMetadataManifest.UploadedMetadataAttribute uploadedHashesOfConsistentSettings;
+        ClusterMetadataManifest.UploadedMetadataAttribute uploadedIndicesRoutingDiffMetadata;
 
         public UploadedMetadataResults(
             List<ClusterMetadataManifest.UploadedIndexMetadata> uploadedIndexMetadata,
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteGlobalMetadataManager.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteGlobalMetadataManager.java
index 2c5aad99adc0c..5a6f4b7e9f1f1 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/RemoteGlobalMetadataManager.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteGlobalMetadataManager.java
@@ -8,7 +8,6 @@
 
 package org.opensearch.gateway.remote;
 
-import org.opensearch.action.LatchedActionListener;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.DiffableUtils;
 import org.opensearch.cluster.DiffableUtils.NonDiffableValueSerializer;
@@ -17,9 +16,8 @@
 import org.opensearch.cluster.metadata.Metadata.Custom;
 import org.opensearch.cluster.metadata.Metadata.XContentContext;
 import org.opensearch.cluster.metadata.TemplatesMetadata;
-import org.opensearch.common.CheckedRunnable;
 import org.opensearch.common.remote.AbstractRemoteWritableBlobEntity;
-import org.opensearch.common.remote.RemoteWritableEntityStore;
+import org.opensearch.common.remote.AbstractRemoteWritableEntityManager;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
@@ -43,7 +41,6 @@
 
 import java.io.IOException;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -56,7 +53,7 @@
  *
  * @opensearch.internal
  */
-public class RemoteGlobalMetadataManager {
+public class RemoteGlobalMetadataManager extends AbstractRemoteWritableEntityManager {
 
     public static final TimeValue GLOBAL_METADATA_UPLOAD_TIMEOUT_DEFAULT = TimeValue.timeValueMillis(20000);
 
@@ -70,7 +67,6 @@ public class RemoteGlobalMetadataManager {
     public static final int GLOBAL_METADATA_CURRENT_CODEC_VERSION = 1;
 
     private volatile TimeValue globalMetadataUploadTimeout;
-    private Map<String, RemoteWritableEntityStore> remoteWritableEntityStores;
     private final Compressor compressor;
     private final NamedXContentRegistry namedXContentRegistry;
     private final NamedWriteableRegistry namedWriteableRegistry;
@@ -87,7 +83,6 @@ public class RemoteGlobalMetadataManager {
         this.compressor = blobStoreRepository.getCompressor();
         this.namedXContentRegistry = blobStoreRepository.getNamedXContentRegistry();
         this.namedWriteableRegistry = namedWriteableRegistry;
-        this.remoteWritableEntityStores = new HashMap<>();
         this.remoteWritableEntityStores.put(
             RemoteGlobalMetadata.GLOBAL_METADATA,
             new RemoteClusterStateBlobStore<>(
@@ -161,46 +156,28 @@ public class RemoteGlobalMetadataManager {
         clusterSettings.addSettingsUpdateConsumer(GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING, this::setGlobalMetadataUploadTimeout);
     }
 
-    /**
-     * Allows async upload of Metadata components to remote
-     */
-    CheckedRunnable<IOException> getAsyncMetadataWriteAction(
-        AbstractRemoteWritableBlobEntity writeEntity,
-        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
-    ) {
-        return (() -> getStore(writeEntity).writeAsync(writeEntity, getActionListener(writeEntity, latchedActionListener)));
-    }
-
-    private RemoteWritableEntityStore getStore(AbstractRemoteWritableBlobEntity entity) {
-        RemoteWritableEntityStore remoteStore = remoteWritableEntityStores.get(entity.getType());
-        if (remoteStore == null) {
-            throw new IllegalArgumentException("Unknown entity type [" + entity.getType() + "]");
-        }
-        return remoteStore;
-    }
-
-    private ActionListener<Void> getActionListener(
-        AbstractRemoteWritableBlobEntity remoteBlobStoreObject,
-        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
+    @Override
+    protected ActionListener<Void> getWrappedWriteListener(
+        String component,
+        AbstractRemoteWritableBlobEntity remoteEntity,
+        ActionListener<ClusterMetadataManifest.UploadedMetadata> listener
     ) {
         return ActionListener.wrap(
-            resp -> latchedActionListener.onResponse(remoteBlobStoreObject.getUploadedMetadata()),
-            ex -> latchedActionListener.onFailure(
-                new RemoteStateTransferException("Upload failed for " + remoteBlobStoreObject.getType(), ex)
-            )
+            resp -> listener.onResponse(remoteEntity.getUploadedMetadata()),
+            ex -> listener.onFailure(new RemoteStateTransferException("Upload failed for " + component, remoteEntity, ex))
         );
     }
 
-    CheckedRunnable<IOException> getAsyncMetadataReadAction(
-        AbstractRemoteWritableBlobEntity readEntity,
-        String componentName,
-        LatchedActionListener<RemoteReadResult> listener
+    @Override
+    protected ActionListener<Object> getWrappedReadListener(
+        String component,
+        AbstractRemoteWritableBlobEntity remoteEntity,
+        ActionListener<RemoteReadResult> listener
     ) {
-        ActionListener actionListener = ActionListener.wrap(
-            response -> listener.onResponse(new RemoteReadResult(response, readEntity.getType(), componentName)),
-            listener::onFailure
+        return ActionListener.wrap(
+            response -> listener.onResponse(new RemoteReadResult(response, remoteEntity.getType(), component)),
+            ex -> listener.onFailure(new RemoteStateTransferException("Download failed for " + component, remoteEntity, ex))
         );
-        return () -> getStore(readEntity).readAsync(readEntity, actionListener);
     }
 
     Metadata getGlobalMetadata(String clusterUUID, ClusterMetadataManifest clusterMetadataManifest) {
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteIndexMetadataManager.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteIndexMetadataManager.java
index c595f19279354..c30721c8f625c 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/RemoteIndexMetadataManager.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteIndexMetadataManager.java
@@ -8,10 +8,9 @@
 
 package org.opensearch.gateway.remote;
 
-import org.opensearch.action.LatchedActionListener;
 import org.opensearch.cluster.metadata.IndexMetadata;
-import org.opensearch.common.CheckedRunnable;
-import org.opensearch.common.remote.RemoteWritableEntityStore;
+import org.opensearch.common.remote.AbstractRemoteWritableBlobEntity;
+import org.opensearch.common.remote.AbstractRemoteWritableEntityManager;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.unit.TimeValue;
@@ -33,7 +32,7 @@
  *
  * @opensearch.internal
  */
-public class RemoteIndexMetadataManager {
+public class RemoteIndexMetadataManager extends AbstractRemoteWritableEntityManager {
 
     public static final TimeValue INDEX_METADATA_UPLOAD_TIMEOUT_DEFAULT = TimeValue.timeValueMillis(20000);
 
@@ -45,7 +44,6 @@ public class RemoteIndexMetadataManager {
         Setting.Property.Deprecated
     );
 
-    private final RemoteWritableEntityStore<IndexMetadata, RemoteIndexMetadata> indexMetadataBlobStore;
     private final Compressor compressor;
     private final NamedXContentRegistry namedXContentRegistry;
 
@@ -58,12 +56,15 @@ public RemoteIndexMetadataManager(
         BlobStoreTransferService blobStoreTransferService,
         ThreadPool threadpool
     ) {
-        this.indexMetadataBlobStore = new RemoteClusterStateBlobStore<>(
-            blobStoreTransferService,
-            blobStoreRepository,
-            clusterName,
-            threadpool,
-            ThreadPool.Names.REMOTE_STATE_READ
+        this.remoteWritableEntityStores.put(
+            RemoteIndexMetadata.INDEX,
+            new RemoteClusterStateBlobStore<>(
+                blobStoreTransferService,
+                blobStoreRepository,
+                clusterName,
+                threadpool,
+                ThreadPool.Names.REMOTE_STATE_READ
+            )
         );
         this.namedXContentRegistry = blobStoreRepository.getNamedXContentRegistry();
         this.compressor = blobStoreRepository.getCompressor();
@@ -71,45 +72,6 @@ public RemoteIndexMetadataManager(
         clusterSettings.addSettingsUpdateConsumer(INDEX_METADATA_UPLOAD_TIMEOUT_SETTING, this::setIndexMetadataUploadTimeout);
     }
 
-    /**
-     * Allows async Upload of IndexMetadata to remote
-     *
-     * @param indexMetadata {@link IndexMetadata} to upload
-     * @param latchedActionListener listener to respond back on after upload finishes
-     */
-    CheckedRunnable<IOException> getAsyncIndexMetadataWriteAction(
-        IndexMetadata indexMetadata,
-        String clusterUUID,
-        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
-    ) {
-        RemoteIndexMetadata remoteIndexMetadata = new RemoteIndexMetadata(indexMetadata, clusterUUID, compressor, namedXContentRegistry);
-        ActionListener<Void> completionListener = ActionListener.wrap(
-            resp -> latchedActionListener.onResponse(remoteIndexMetadata.getUploadedMetadata()),
-            ex -> latchedActionListener.onFailure(new RemoteStateTransferException(indexMetadata.getIndex().getName(), ex))
-        );
-        return () -> indexMetadataBlobStore.writeAsync(remoteIndexMetadata, completionListener);
-    }
-
-    CheckedRunnable<IOException> getAsyncIndexMetadataReadAction(
-        String clusterUUID,
-        String uploadedFilename,
-        LatchedActionListener<RemoteReadResult> latchedActionListener
-    ) {
-        RemoteIndexMetadata remoteIndexMetadata = new RemoteIndexMetadata(
-            RemoteClusterStateUtils.getFormattedIndexFileName(uploadedFilename),
-            clusterUUID,
-            compressor,
-            namedXContentRegistry
-        );
-        ActionListener<IndexMetadata> actionListener = ActionListener.wrap(
-            response -> latchedActionListener.onResponse(
-                new RemoteReadResult(response, RemoteIndexMetadata.INDEX, response.getIndex().getName())
-            ),
-            latchedActionListener::onFailure
-        );
-        return () -> indexMetadataBlobStore.readAsync(remoteIndexMetadata, actionListener);
-    }
-
     /**
      * Fetch index metadata from remote cluster state
      *
@@ -124,7 +86,7 @@ IndexMetadata getIndexMetadata(ClusterMetadataManifest.UploadedIndexMetadata upl
             namedXContentRegistry
         );
         try {
-            return indexMetadataBlobStore.read(remoteIndexMetadata);
+            return (IndexMetadata) getStore(remoteIndexMetadata).read(remoteIndexMetadata);
         } catch (IOException e) {
             throw new IllegalStateException(
                 String.format(Locale.ROOT, "Error while downloading IndexMetadata - %s", uploadedIndexMetadata.getUploadedFilename()),
@@ -141,4 +103,27 @@ private void setIndexMetadataUploadTimeout(TimeValue newIndexMetadataUploadTimeo
         this.indexMetadataUploadTimeout = newIndexMetadataUploadTimeout;
     }
 
+    @Override
+    protected ActionListener<Void> getWrappedWriteListener(
+        String component,
+        AbstractRemoteWritableBlobEntity remoteEntity,
+        ActionListener<ClusterMetadataManifest.UploadedMetadata> listener
+    ) {
+        return ActionListener.wrap(
+            resp -> listener.onResponse(remoteEntity.getUploadedMetadata()),
+            ex -> listener.onFailure(new RemoteStateTransferException("Upload failed for " + component, remoteEntity, ex))
+        );
+    }
+
+    @Override
+    protected ActionListener<Object> getWrappedReadListener(
+        String component,
+        AbstractRemoteWritableBlobEntity remoteEntity,
+        ActionListener<RemoteReadResult> listener
+    ) {
+        return ActionListener.wrap(
+            response -> listener.onResponse(new RemoteReadResult(response, RemoteIndexMetadata.INDEX, component)),
+            ex -> listener.onFailure(new RemoteStateTransferException("Download failed for " + component, remoteEntity, ex))
+        );
+    }
 }
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemotePersistenceStats.java b/server/src/main/java/org/opensearch/gateway/remote/RemotePersistenceStats.java
index 36d107a99d258..efd73e11e46b5 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/RemotePersistenceStats.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemotePersistenceStats.java
@@ -20,15 +20,18 @@
 public class RemotePersistenceStats extends PersistedStateStats {
     static final String CLEANUP_ATTEMPT_FAILED_COUNT = "cleanup_attempt_failed_count";
     static final String INDEX_ROUTING_FILES_CLEANUP_ATTEMPT_FAILED_COUNT = "index_routing_files_cleanup_attempt_failed_count";
+    static final String INDICES_ROUTING_DIFF_FILES_CLEANUP_ATTEMPT_FAILED_COUNT = "indices_routing_diff_files_cleanup_attempt_failed_count";
     static final String REMOTE_UPLOAD = "remote_upload";
     private AtomicLong cleanupAttemptFailedCount = new AtomicLong(0);
 
     private AtomicLong indexRoutingFilesCleanupAttemptFailedCount = new AtomicLong(0);
+    private AtomicLong indicesRoutingDiffFilesCleanupAttemptFailedCount = new AtomicLong(0);
 
     public RemotePersistenceStats() {
         super(REMOTE_UPLOAD);
         addToExtendedFields(CLEANUP_ATTEMPT_FAILED_COUNT, cleanupAttemptFailedCount);
         addToExtendedFields(INDEX_ROUTING_FILES_CLEANUP_ATTEMPT_FAILED_COUNT, indexRoutingFilesCleanupAttemptFailedCount);
+        addToExtendedFields(INDICES_ROUTING_DIFF_FILES_CLEANUP_ATTEMPT_FAILED_COUNT, indicesRoutingDiffFilesCleanupAttemptFailedCount);
     }
 
     public void cleanUpAttemptFailed() {
@@ -46,4 +49,12 @@ public void indexRoutingFilesCleanupAttemptFailed() {
     public long getIndexRoutingFilesCleanupAttemptFailedCount() {
         return indexRoutingFilesCleanupAttemptFailedCount.get();
     }
+
+    public void indicesRoutingDiffFileCleanupAttemptFailed() {
+        indexRoutingFilesCleanupAttemptFailedCount.incrementAndGet();
+    }
+
+    public long getIndicesRoutingDiffFileCleanupAttemptFailedCount() {
+        return indexRoutingFilesCleanupAttemptFailedCount.get();
+    }
 }
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterMetadataManifest.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterMetadataManifest.java
index 1dc56712d4ab5..acaae3173315a 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterMetadataManifest.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterMetadataManifest.java
@@ -35,7 +35,7 @@ public class RemoteClusterMetadataManifest extends AbstractRemoteWritableBlobEnt
     public static final int SPLITTED_MANIFEST_FILE_LENGTH = 6;
 
     public static final String METADATA_MANIFEST_NAME_FORMAT = "%s";
-    public static final int MANIFEST_CURRENT_CODEC_VERSION = ClusterMetadataManifest.CODEC_V2;
+    public static final int MANIFEST_CURRENT_CODEC_VERSION = ClusterMetadataManifest.CODEC_V3;
     public static final String COMMITTED = "C";
     public static final String PUBLISHED = "P";
 
@@ -50,6 +50,9 @@ public class RemoteClusterMetadataManifest extends AbstractRemoteWritableBlobEnt
     public static final ChecksumBlobStoreFormat<ClusterMetadataManifest> CLUSTER_METADATA_MANIFEST_FORMAT_V1 =
         new ChecksumBlobStoreFormat<>("cluster-metadata-manifest", METADATA_MANIFEST_NAME_FORMAT, ClusterMetadataManifest::fromXContentV1);
 
+    public static final ChecksumBlobStoreFormat<ClusterMetadataManifest> CLUSTER_METADATA_MANIFEST_FORMAT_V2 =
+        new ChecksumBlobStoreFormat<>("cluster-metadata-manifest", METADATA_MANIFEST_NAME_FORMAT, ClusterMetadataManifest::fromXContentV2);
+
     /**
      * Manifest format compatible with codec v2, where we introduced codec versions/global metadata.
      */
@@ -149,6 +152,8 @@ private ChecksumBlobStoreFormat<ClusterMetadataManifest> getClusterMetadataManif
         long codecVersion = getManifestCodecVersion();
         if (codecVersion == MANIFEST_CURRENT_CODEC_VERSION) {
             return CLUSTER_METADATA_MANIFEST_FORMAT;
+        } else if (codecVersion == ClusterMetadataManifest.CODEC_V2) {
+            return CLUSTER_METADATA_MANIFEST_FORMAT_V2;
         } else if (codecVersion == ClusterMetadataManifest.CODEC_V1) {
             return CLUSTER_METADATA_MANIFEST_FORMAT_V1;
         } else if (codecVersion == ClusterMetadataManifest.CODEC_V0) {
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterStateBlobStore.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterStateBlobStore.java
index 1dd23443f1252..cd8b8aa41ad65 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterStateBlobStore.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterStateBlobStore.java
@@ -23,6 +23,8 @@
 import java.io.InputStream;
 import java.util.concurrent.ExecutorService;
 
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN;
+
 /**
  * Abstract class for a blob type storage
  *
@@ -88,18 +90,26 @@ public void readAsync(final U entity, final ActionListener<T> listener) {
         });
     }
 
-    private BlobPath getBlobPathForUpload(final AbstractRemoteWritableBlobEntity<T> obj) {
-        BlobPath blobPath = blobStoreRepository.basePath()
-            .add(RemoteClusterStateUtils.encodeString(clusterName))
-            .add("cluster-state")
-            .add(obj.clusterUUID());
+    public String getClusterName() {
+        return clusterName;
+    }
+
+    public BlobPath getBlobPathPrefix(String clusterUUID) {
+        return blobStoreRepository.basePath()
+            .add(RemoteClusterStateUtils.encodeString(getClusterName()))
+            .add(CLUSTER_STATE_PATH_TOKEN)
+            .add(clusterUUID);
+    }
+
+    public BlobPath getBlobPathForUpload(final AbstractRemoteWritableBlobEntity<T> obj) {
+        BlobPath blobPath = getBlobPathPrefix(obj.clusterUUID());
         for (String token : obj.getBlobPathParameters().getPathTokens()) {
             blobPath = blobPath.add(token);
         }
         return blobPath;
     }
 
-    private BlobPath getBlobPathForDownload(final AbstractRemoteWritableBlobEntity<T> obj) {
+    public BlobPath getBlobPathForDownload(final AbstractRemoteWritableBlobEntity<T> obj) {
         String[] pathTokens = obj.getBlobPathTokens();
         BlobPath blobPath = new BlobPath();
         if (pathTokens == null || pathTokens.length < 1) {
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteRoutingTableBlobStore.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteRoutingTableBlobStore.java
new file mode 100644
index 0000000000000..7c4a5bf2236a1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteRoutingTableBlobStore.java
@@ -0,0 +1,108 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.remote.AbstractRemoteWritableBlobEntity;
+import org.opensearch.common.remote.RemoteWriteableEntity;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable;
+import org.opensearch.index.remote.RemoteStoreEnums;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.threadpool.ThreadPool;
+
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_TABLE;
+
+/**
+ * Extends the RemoteClusterStateBlobStore to support {@link RemoteIndexRoutingTable}
+ *
+ * @param <IndexRoutingTable> which can be uploaded to / downloaded from blob store
+ * @param <U> The concrete class implementing {@link RemoteWriteableEntity} which is used as a wrapper for IndexRoutingTable entity.
+ */
+public class RemoteRoutingTableBlobStore<IndexRoutingTable, U extends AbstractRemoteWritableBlobEntity<IndexRoutingTable>> extends
+    RemoteClusterStateBlobStore<IndexRoutingTable, U> {
+
+    /**
+     * This setting is used to set the remote routing table store blob store path type strategy.
+     */
+    public static final Setting<RemoteStoreEnums.PathType> REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING = new Setting<>(
+        "cluster.remote_store.routing_table.path_type",
+        RemoteStoreEnums.PathType.HASHED_PREFIX.toString(),
+        RemoteStoreEnums.PathType::parseString,
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
+    /**
+     * This setting is used to set the remote routing table store blob store path hash algorithm strategy.
+     * This setting will come to effect if the {@link #REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING}
+     * is either {@code HASHED_PREFIX} or {@code HASHED_INFIX}.
+     */
+    public static final Setting<RemoteStoreEnums.PathHashAlgorithm> REMOTE_ROUTING_TABLE_PATH_HASH_ALGO_SETTING = new Setting<>(
+        "cluster.remote_store.routing_table.path_hash_algo",
+        RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64.toString(),
+        RemoteStoreEnums.PathHashAlgorithm::parseString,
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
+    private RemoteStoreEnums.PathType pathType;
+    private RemoteStoreEnums.PathHashAlgorithm pathHashAlgo;
+
+    public RemoteRoutingTableBlobStore(
+        BlobStoreTransferService blobStoreTransferService,
+        BlobStoreRepository blobStoreRepository,
+        String clusterName,
+        ThreadPool threadPool,
+        String executor,
+        ClusterSettings clusterSettings
+    ) {
+        super(blobStoreTransferService, blobStoreRepository, clusterName, threadPool, executor);
+        this.pathType = clusterSettings.get(REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING);
+        this.pathHashAlgo = clusterSettings.get(REMOTE_ROUTING_TABLE_PATH_HASH_ALGO_SETTING);
+        clusterSettings.addSettingsUpdateConsumer(REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING, this::setPathTypeSetting);
+        clusterSettings.addSettingsUpdateConsumer(REMOTE_ROUTING_TABLE_PATH_HASH_ALGO_SETTING, this::setPathHashAlgoSetting);
+    }
+
+    @Override
+    public BlobPath getBlobPathForUpload(final AbstractRemoteWritableBlobEntity<IndexRoutingTable> obj) {
+        assert obj.getBlobPathParameters().getPathTokens().size() == 1 : "Unexpected tokens in RemoteRoutingTableObject";
+        BlobPath indexRoutingPath = getBlobPathPrefix(obj.clusterUUID()).add(INDEX_ROUTING_TABLE);
+
+        BlobPath path = pathType.path(
+            RemoteStorePathStrategy.PathInput.builder()
+                .basePath(indexRoutingPath)
+                .indexUUID(String.join("", obj.getBlobPathParameters().getPathTokens()))
+                .build(),
+            pathHashAlgo
+        );
+        return path;
+    }
+
+    private void setPathTypeSetting(RemoteStoreEnums.PathType pathType) {
+        this.pathType = pathType;
+    }
+
+    private void setPathHashAlgoSetting(RemoteStoreEnums.PathHashAlgorithm pathHashAlgo) {
+        this.pathHashAlgo = pathHashAlgo;
+    }
+
+    // For testing only
+    protected RemoteStoreEnums.PathType getPathTypeSetting() {
+        return pathType;
+    }
+
+    // For testing only
+    protected RemoteStoreEnums.PathHashAlgorithm getPathHashAlgoSetting() {
+        return pathHashAlgo;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/routingtable/IndexRoutingTableHeader.java b/server/src/main/java/org/opensearch/gateway/remote/routingtable/IndexRoutingTableHeader.java
deleted file mode 100644
index 5baea6adba0c7..0000000000000
--- a/server/src/main/java/org/opensearch/gateway/remote/routingtable/IndexRoutingTableHeader.java
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.gateway.remote.routingtable;
-
-import org.apache.lucene.codecs.CodecUtil;
-import org.apache.lucene.index.CorruptIndexException;
-import org.apache.lucene.index.IndexFormatTooNewException;
-import org.apache.lucene.index.IndexFormatTooOldException;
-import org.apache.lucene.store.InputStreamDataInput;
-import org.apache.lucene.store.OutputStreamDataOutput;
-import org.opensearch.core.common.io.stream.StreamInput;
-import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.core.common.io.stream.Writeable;
-
-import java.io.EOFException;
-import java.io.IOException;
-
-/**
- * The stored header information for the individual index routing table
- */
-public class IndexRoutingTableHeader implements Writeable {
-
-    public static final String INDEX_ROUTING_HEADER_CODEC = "index_routing_header_codec";
-    public static final int INITIAL_VERSION = 1;
-    public static final int CURRENT_VERSION = INITIAL_VERSION;
-    private final String indexName;
-
-    public IndexRoutingTableHeader(String indexName) {
-        this.indexName = indexName;
-    }
-
-    /**
-     * Reads the contents on the stream into the corresponding {@link IndexRoutingTableHeader}
-     *
-     * @param in streamInput
-     * @throws IOException exception thrown on failing to read from stream.
-     */
-    public IndexRoutingTableHeader(StreamInput in) throws IOException {
-        try {
-            readHeaderVersion(in);
-            indexName = in.readString();
-        } catch (EOFException e) {
-            throw new IOException("index routing header truncated", e);
-        }
-    }
-
-    private void readHeaderVersion(final StreamInput in) throws IOException {
-        try {
-            CodecUtil.checkHeader(new InputStreamDataInput(in), INDEX_ROUTING_HEADER_CODEC, INITIAL_VERSION, CURRENT_VERSION);
-        } catch (CorruptIndexException | IndexFormatTooOldException | IndexFormatTooNewException e) {
-            throw new IOException("index routing table header corrupted", e);
-        }
-    }
-
-    /**
-     * Write the IndexRoutingTable to given stream.
-     *
-     * @param out stream to write
-     * @throws IOException exception thrown on failing to write to stream.
-     */
-    public void writeTo(StreamOutput out) throws IOException {
-        try {
-            CodecUtil.writeHeader(new OutputStreamDataOutput(out), INDEX_ROUTING_HEADER_CODEC, CURRENT_VERSION);
-            out.writeString(indexName);
-            out.flush();
-        } catch (IOException e) {
-            throw new IOException("Failed to write IndexRoutingTable header", e);
-        }
-    }
-
-    public String getIndexName() {
-        return indexName;
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTable.java b/server/src/main/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTable.java
index 17c55190da07f..40b5bafde2b13 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTable.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTable.java
@@ -9,92 +9,106 @@
 package org.opensearch.gateway.remote.routingtable;
 
 import org.opensearch.cluster.routing.IndexRoutingTable;
-import org.opensearch.cluster.routing.IndexShardRoutingTable;
-import org.opensearch.core.common.io.stream.BufferedChecksumStreamInput;
-import org.opensearch.core.common.io.stream.BufferedChecksumStreamOutput;
-import org.opensearch.core.common.io.stream.InputStreamStreamInput;
-import org.opensearch.core.common.io.stream.StreamOutput;
-import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractRemoteWritableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.compress.Compressor;
 import org.opensearch.core.index.Index;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.repositories.blobstore.ChecksumWritableBlobStoreFormat;
 
-import java.io.EOFException;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
 
 /**
  * Remote store object for IndexRoutingTable
  */
-public class RemoteIndexRoutingTable implements Writeable {
+public class RemoteIndexRoutingTable extends AbstractRemoteWritableBlobEntity<IndexRoutingTable> {
 
-    private final IndexRoutingTable indexRoutingTable;
+    public static final String INDEX_ROUTING_TABLE = "index-routing";
+    public static final String INDEX_ROUTING_METADATA_PREFIX = "indexRouting--";
+    public static final String INDEX_ROUTING_FILE = "index_routing";
+    private IndexRoutingTable indexRoutingTable;
+    private final Index index;
+    private long term;
+    private long version;
+    private BlobPathParameters blobPathParameters;
+    public static final ChecksumWritableBlobStoreFormat<IndexRoutingTable> INDEX_ROUTING_TABLE_FORMAT =
+        new ChecksumWritableBlobStoreFormat<>("index-routing-table", IndexRoutingTable::readFrom);
 
-    public RemoteIndexRoutingTable(IndexRoutingTable indexRoutingTable) {
+    public RemoteIndexRoutingTable(
+        IndexRoutingTable indexRoutingTable,
+        String clusterUUID,
+        Compressor compressor,
+        long term,
+        long version
+    ) {
+        super(clusterUUID, compressor);
+        this.index = indexRoutingTable.getIndex();
         this.indexRoutingTable = indexRoutingTable;
+        this.term = term;
+        this.version = version;
     }
 
     /**
      * Reads data from inputStream and creates RemoteIndexRoutingTable object with the {@link IndexRoutingTable}
-     * @param inputStream input stream with index routing data
-     * @param index index for the current routing data
-     * @throws IOException exception thrown on failing to read from stream.
+     * @param blobName name of the blob, which contains the index routing data
+     * @param clusterUUID UUID of the cluster
+     * @param compressor Compressor object
      */
-    public RemoteIndexRoutingTable(InputStream inputStream, Index index) throws IOException {
-        try {
-            try (BufferedChecksumStreamInput in = new BufferedChecksumStreamInput(new InputStreamStreamInput(inputStream), "assertion")) {
-                // Read the Table Header first and confirm the index
-                IndexRoutingTableHeader indexRoutingTableHeader = new IndexRoutingTableHeader(in);
-                assert indexRoutingTableHeader.getIndexName().equals(index.getName());
+    public RemoteIndexRoutingTable(String blobName, String clusterUUID, Compressor compressor) {
+        super(clusterUUID, compressor);
+        this.index = null;
+        this.term = -1;
+        this.version = -1;
+        this.blobName = blobName;
+    }
 
-                int numberOfShardRouting = in.readVInt();
-                IndexRoutingTable.Builder indicesRoutingTable = IndexRoutingTable.builder(index);
-                for (int idx = 0; idx < numberOfShardRouting; idx++) {
-                    IndexShardRoutingTable indexShardRoutingTable = IndexShardRoutingTable.Builder.readFrom(in);
-                    indicesRoutingTable.addIndexShard(indexShardRoutingTable);
-                }
-                verifyCheckSum(in);
-                indexRoutingTable = indicesRoutingTable.build();
-            }
-        } catch (EOFException e) {
-            throw new IOException("Indices Routing table is corrupted", e);
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        if (blobPathParameters == null) {
+            blobPathParameters = new BlobPathParameters(List.of(indexRoutingTable.getIndex().getUUID()), INDEX_ROUTING_FILE);
         }
+        return blobPathParameters;
     }
 
-    public IndexRoutingTable getIndexRoutingTable() {
-        return indexRoutingTable;
+    @Override
+    public String getType() {
+        return INDEX_ROUTING_TABLE;
     }
 
-    /**
-     * Writes {@link IndexRoutingTable} to the given stream
-     * @param streamOutput output stream to write
-     * @throws IOException exception thrown on failing to write to stream.
-     */
     @Override
-    public void writeTo(StreamOutput streamOutput) throws IOException {
-        try {
-            BufferedChecksumStreamOutput out = new BufferedChecksumStreamOutput(streamOutput);
-            IndexRoutingTableHeader indexRoutingTableHeader = new IndexRoutingTableHeader(indexRoutingTable.getIndex().getName());
-            indexRoutingTableHeader.writeTo(out);
-            out.writeVInt(indexRoutingTable.shards().size());
-            for (IndexShardRoutingTable next : indexRoutingTable) {
-                IndexShardRoutingTable.Builder.writeTo(next, out);
-            }
-            out.writeLong(out.getChecksum());
-            out.flush();
-        } catch (IOException e) {
-            throw new IOException("Failed to write IndexRoutingTable to stream", e);
+    public String generateBlobFileName() {
+        if (blobFileName == null) {
+            blobFileName = String.join(
+                DELIMITER,
+                getBlobPathParameters().getFilePrefix(),
+                RemoteStoreUtils.invertLong(term),
+                RemoteStoreUtils.invertLong(version),
+                RemoteStoreUtils.invertLong(System.currentTimeMillis())
+            );
         }
+        return blobFileName;
     }
 
-    private void verifyCheckSum(BufferedChecksumStreamInput in) throws IOException {
-        long expectedChecksum = in.getChecksum();
-        long readChecksum = in.readLong();
-        if (readChecksum != expectedChecksum) {
-            throw new IOException(
-                "checksum verification failed - expected: 0x"
-                    + Long.toHexString(expectedChecksum)
-                    + ", got: 0x"
-                    + Long.toHexString(readChecksum)
-            );
-        }
+    @Override
+    public ClusterMetadataManifest.UploadedMetadata getUploadedMetadata() {
+        assert blobName != null;
+        assert index != null;
+        return new ClusterMetadataManifest.UploadedIndexMetadata(index.getName(), index.getUUID(), blobName, INDEX_ROUTING_METADATA_PREFIX);
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        return INDEX_ROUTING_TABLE_FORMAT.serialize(indexRoutingTable, generateBlobFileName(), getCompressor()).streamInput();
+    }
+
+    @Override
+    public IndexRoutingTable deserialize(InputStream in) throws IOException {
+        return INDEX_ROUTING_TABLE_FORMAT.deserialize(blobName, Streams.readFully(in));
     }
 }
diff --git a/server/src/main/java/org/opensearch/gateway/remote/routingtable/RemoteRoutingTableDiff.java b/server/src/main/java/org/opensearch/gateway/remote/routingtable/RemoteRoutingTableDiff.java
new file mode 100644
index 0000000000000..e876d939490d0
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/routingtable/RemoteRoutingTableDiff.java
@@ -0,0 +1,150 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.routingtable;
+
+import org.opensearch.cluster.Diff;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.RoutingTableIncrementalDiff;
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractRemoteWritableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.repositories.blobstore.ChecksumWritableBlobStoreFormat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.Map;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+
+/**
+ * Represents a incremental difference between {@link org.opensearch.cluster.routing.RoutingTable} objects that can be serialized and deserialized.
+ * This class is responsible for writing and reading the differences between RoutingTables to and from an input/output stream.
+ */
+public class RemoteRoutingTableDiff extends AbstractRemoteWritableBlobEntity<RoutingTableIncrementalDiff> {
+    private final RoutingTableIncrementalDiff routingTableIncrementalDiff;
+
+    private long term;
+    private long version;
+
+    public static final String ROUTING_TABLE_DIFF = "routing-table-diff";
+
+    public static final String ROUTING_TABLE_DIFF_METADATA_PREFIX = "routingTableDiff--";
+
+    public static final String ROUTING_TABLE_DIFF_FILE = "routing_table_diff";
+    private static final String codec = "RemoteRoutingTableDiff";
+    public static final String ROUTING_TABLE_DIFF_PATH_TOKEN = "routing-table-diff";
+
+    public static final int VERSION = 1;
+
+    public static final ChecksumWritableBlobStoreFormat<RoutingTableIncrementalDiff> REMOTE_ROUTING_TABLE_DIFF_FORMAT =
+        new ChecksumWritableBlobStoreFormat<>(codec, RoutingTableIncrementalDiff::readFrom);
+
+    /**
+     * Constructs a new RemoteRoutingTableDiff with the given differences.
+     *
+     * @param routingTableIncrementalDiff a RoutingTableIncrementalDiff object containing the differences of {@link IndexRoutingTable}.
+     * @param clusterUUID the cluster UUID.
+     * @param compressor the compressor to be used.
+     * @param term the term of the routing table.
+     * @param version the version of the routing table.
+     */
+    public RemoteRoutingTableDiff(
+        RoutingTableIncrementalDiff routingTableIncrementalDiff,
+        String clusterUUID,
+        Compressor compressor,
+        long term,
+        long version
+    ) {
+        super(clusterUUID, compressor);
+        this.routingTableIncrementalDiff = routingTableIncrementalDiff;
+        this.term = term;
+        this.version = version;
+    }
+
+    /**
+     * Constructs a new RemoteRoutingTableDiff with the given differences.
+     *
+     * @param routingTableIncrementalDiff a RoutingTableIncrementalDiff object containing the differences of {@link IndexRoutingTable}.
+     * @param clusterUUID the cluster UUID.
+     * @param compressor the compressor to be used.
+     */
+    public RemoteRoutingTableDiff(RoutingTableIncrementalDiff routingTableIncrementalDiff, String clusterUUID, Compressor compressor) {
+        super(clusterUUID, compressor);
+        this.routingTableIncrementalDiff = routingTableIncrementalDiff;
+    }
+
+    /**
+     * Constructs a new RemoteIndexRoutingTableDiff with the given blob name, cluster UUID, and compressor.
+     *
+     * @param blobName the name of the blob.
+     * @param clusterUUID the cluster UUID.
+     * @param compressor the compressor to be used.
+     */
+    public RemoteRoutingTableDiff(String blobName, String clusterUUID, Compressor compressor) {
+        super(clusterUUID, compressor);
+        this.routingTableIncrementalDiff = null;
+        this.blobName = blobName;
+    }
+
+    /**
+     * Gets the map of differences of {@link IndexRoutingTable}.
+     *
+     * @return a map containing the differences.
+     */
+    public Map<String, Diff<IndexRoutingTable>> getDiffs() {
+        assert routingTableIncrementalDiff != null;
+        return routingTableIncrementalDiff.getDiffs();
+    }
+
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        return new BlobPathParameters(List.of(ROUTING_TABLE_DIFF_PATH_TOKEN), ROUTING_TABLE_DIFF_METADATA_PREFIX);
+    }
+
+    @Override
+    public String getType() {
+        return ROUTING_TABLE_DIFF;
+    }
+
+    @Override
+    public String generateBlobFileName() {
+        if (blobFileName == null) {
+            blobFileName = String.join(
+                DELIMITER,
+                getBlobPathParameters().getFilePrefix(),
+                RemoteStoreUtils.invertLong(term),
+                RemoteStoreUtils.invertLong(version),
+                RemoteStoreUtils.invertLong(System.currentTimeMillis())
+            );
+        }
+        return blobFileName;
+    }
+
+    @Override
+    public ClusterMetadataManifest.UploadedMetadata getUploadedMetadata() {
+        assert blobName != null;
+        return new ClusterMetadataManifest.UploadedMetadataAttribute(ROUTING_TABLE_DIFF_FILE, blobName);
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        assert routingTableIncrementalDiff != null;
+        return REMOTE_ROUTING_TABLE_DIFF_FORMAT.serialize(routingTableIncrementalDiff, generateBlobFileName(), getCompressor())
+            .streamInput();
+    }
+
+    @Override
+    public RoutingTableIncrementalDiff deserialize(InputStream in) throws IOException {
+        return REMOTE_ROUTING_TABLE_DIFF_FORMAT.deserialize(blobName, Streams.readFully(in));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/IndexModule.java b/server/src/main/java/org/opensearch/index/IndexModule.java
index 09b904394ee09..93ff1b78b1ac5 100644
--- a/server/src/main/java/org/opensearch/index/IndexModule.java
+++ b/server/src/main/java/org/opensearch/index/IndexModule.java
@@ -48,6 +48,7 @@
 import org.opensearch.common.CheckedFunction;
 import org.opensearch.common.SetOnce;
 import org.opensearch.common.TriFunction;
+import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.settings.Setting;
@@ -174,6 +175,14 @@ public final class IndexModule {
         Property.NodeScope
     );
 
+    public static final Setting<String> INDEX_TIERING_STATE = new Setting<>(
+        "index.tiering.state",
+        TieringState.HOT.name(),
+        Function.identity(),
+        Property.IndexScope,
+        Property.PrivateIndex
+    );
+
     /** Which lucene file extensions to load with the mmap directory when using hybridfs store. This settings is ignored if {@link #INDEX_STORE_HYBRID_NIO_EXTENSIONS} is set.
      *  This is an expert setting.
      *  @see <a href="https://lucene.apache.org/core/9_9_0/core/org/apache/lucene/codecs/lucene99/package-summary.html#file-names">Lucene File Extensions</a>.
@@ -663,6 +672,17 @@ public static Type defaultStoreType(final boolean allowMmap) {
         }
     }
 
+    /**
+     * Represents the tiering state of the index.
+     */
+    @ExperimentalApi
+    public enum TieringState {
+        HOT,
+        HOT_TO_WARM,
+        WARM,
+        WARM_TO_HOT;
+    }
+
     public IndexService newIndexService(
         IndexService.IndexCreationContext indexCreationContext,
         NodeEnvironment environment,
diff --git a/server/src/main/java/org/opensearch/index/codec/composite/Composite99DocValuesWriter.java b/server/src/main/java/org/opensearch/index/codec/composite/Composite99DocValuesWriter.java
index 75bbf78dbdad2..3753b20a8bea3 100644
--- a/server/src/main/java/org/opensearch/index/codec/composite/Composite99DocValuesWriter.java
+++ b/server/src/main/java/org/opensearch/index/codec/composite/Composite99DocValuesWriter.java
@@ -14,6 +14,7 @@
 import org.apache.lucene.index.MergeState;
 import org.apache.lucene.index.SegmentWriteState;
 import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.compositeindex.datacube.startree.builder.StarTreesBuilder;
 import org.opensearch.index.mapper.CompositeMappedFieldType;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.mapper.StarTreeMapper;
@@ -98,7 +99,9 @@ private void createCompositeIndicesIfPossible(DocValuesProducer valuesProducer,
         if (compositeFieldSet.isEmpty()) {
             for (CompositeMappedFieldType mappedType : compositeMappedFieldTypes) {
                 if (mappedType instanceof StarTreeMapper.StarTreeFieldType) {
-                    // TODO : Call StarTree builder
+                    try (StarTreesBuilder starTreesBuilder = new StarTreesBuilder(fieldProducerMap, state, mapperService)) {
+                        starTreesBuilder.build();
+                    }
                 }
             }
         }
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeDocument.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeDocument.java
new file mode 100644
index 0000000000000..0ce2b3a5cdac5
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeDocument.java
@@ -0,0 +1,34 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.util.Arrays;
+
+/**
+ * Star tree document
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class StarTreeDocument {
+    public final Long[] dimensions;
+    public final Object[] metrics;
+
+    public StarTreeDocument(Long[] dimensions, Object[] metrics) {
+        this.dimensions = dimensions;
+        this.metrics = metrics;
+    }
+
+    @Override
+    public String toString() {
+        return Arrays.toString(dimensions) + " | " + Arrays.toString(metrics);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/CountValueAggregator.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/CountValueAggregator.java
new file mode 100644
index 0000000000000..d72f4a292dc0a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/CountValueAggregator.java
@@ -0,0 +1,66 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.numerictype.StarTreeNumericType;
+
+/**
+ * Count value aggregator for star tree
+ *
+ * @opensearch.experimental
+ */
+public class CountValueAggregator implements ValueAggregator<Long> {
+    public static final StarTreeNumericType VALUE_AGGREGATOR_TYPE = StarTreeNumericType.LONG;
+    public static final long DEFAULT_INITIAL_VALUE = 1L;
+
+    @Override
+    public MetricStat getAggregationType() {
+        return MetricStat.COUNT;
+    }
+
+    @Override
+    public StarTreeNumericType getAggregatedValueType() {
+        return VALUE_AGGREGATOR_TYPE;
+    }
+
+    @Override
+    public Long getInitialAggregatedValueForSegmentDocValue(Long segmentDocValue, StarTreeNumericType starTreeNumericType) {
+        return DEFAULT_INITIAL_VALUE;
+    }
+
+    @Override
+    public Long mergeAggregatedValueAndSegmentValue(Long value, Long segmentDocValue, StarTreeNumericType starTreeNumericType) {
+        return value + 1;
+    }
+
+    @Override
+    public Long mergeAggregatedValues(Long value, Long aggregatedValue) {
+        return value + aggregatedValue;
+    }
+
+    @Override
+    public Long getInitialAggregatedValue(Long value) {
+        return value;
+    }
+
+    @Override
+    public int getMaxAggregatedValueByteSize() {
+        return Long.BYTES;
+    }
+
+    @Override
+    public Long toLongValue(Long value) {
+        return value;
+    }
+
+    @Override
+    public Long toStarTreeNumericTypeValue(Long value, StarTreeNumericType type) {
+        return value;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MetricAggregatorInfo.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MetricAggregatorInfo.java
new file mode 100644
index 0000000000000..46f1b1ac11063
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MetricAggregatorInfo.java
@@ -0,0 +1,130 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.numerictype.StarTreeNumericType;
+import org.opensearch.index.compositeindex.datacube.startree.utils.SequentialDocValuesIterator;
+import org.opensearch.index.fielddata.IndexNumericFieldData;
+
+import java.util.Comparator;
+import java.util.Objects;
+
+/**
+ * Builds aggregation function and doc values field pair to support various aggregations
+ *
+ * @opensearch.experimental
+ */
+public class MetricAggregatorInfo implements Comparable<MetricAggregatorInfo> {
+
+    public static final String DELIMITER = "_";
+    private final String metric;
+    private final String starFieldName;
+    private final MetricStat metricStat;
+    private final String field;
+    private final ValueAggregator valueAggregators;
+    private final StarTreeNumericType starTreeNumericType;
+    private final SequentialDocValuesIterator metricStatReader;
+
+    /**
+     * Constructor for MetricAggregatorInfo
+     */
+    public MetricAggregatorInfo(
+        MetricStat metricStat,
+        String field,
+        String starFieldName,
+        IndexNumericFieldData.NumericType numericType,
+        SequentialDocValuesIterator metricStatReader
+    ) {
+        this.metricStat = metricStat;
+        this.valueAggregators = ValueAggregatorFactory.getValueAggregator(metricStat);
+        this.starTreeNumericType = StarTreeNumericType.fromNumericType(numericType);
+        this.metricStatReader = metricStatReader;
+        this.field = field;
+        this.starFieldName = starFieldName;
+        this.metric = toFieldName();
+    }
+
+    /**
+     * @return metric type
+     */
+    public MetricStat getMetricStat() {
+        return metricStat;
+    }
+
+    /**
+     * @return field Name
+     */
+    public String getField() {
+        return field;
+    }
+
+    /**
+     * @return the metric stat name
+     */
+    public String getMetric() {
+        return metric;
+    }
+
+    /**
+     * @return aggregator for the field value
+     */
+    public ValueAggregator getValueAggregators() {
+        return valueAggregators;
+    }
+
+    /**
+     * @return star tree aggregated value type
+     */
+    public StarTreeNumericType getAggregatedValueType() {
+        return starTreeNumericType;
+    }
+
+    /**
+     * @return metric value reader iterator
+     */
+    public SequentialDocValuesIterator getMetricStatReader() {
+        return metricStatReader;
+    }
+
+    /**
+     * @return field name with metric type and field
+     */
+    public String toFieldName() {
+        return starFieldName + DELIMITER + field + DELIMITER + metricStat.getTypeName();
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(toFieldName());
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof MetricAggregatorInfo) {
+            MetricAggregatorInfo anotherPair = (MetricAggregatorInfo) obj;
+            return metricStat == anotherPair.metricStat && field.equals(anotherPair.field);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return toFieldName();
+    }
+
+    @Override
+    public int compareTo(MetricAggregatorInfo other) {
+        return Comparator.comparing((MetricAggregatorInfo o) -> o.field)
+            .thenComparing((MetricAggregatorInfo o) -> o.metricStat)
+            .compare(this, other);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/SumValueAggregator.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/SumValueAggregator.java
new file mode 100644
index 0000000000000..543b0f7f42374
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/SumValueAggregator.java
@@ -0,0 +1,97 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.apache.lucene.util.NumericUtils;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.numerictype.StarTreeNumericType;
+import org.opensearch.search.aggregations.metrics.CompensatedSum;
+
+/**
+ * Sum value aggregator for star tree
+ *
+ * @opensearch.experimental
+ */
+public class SumValueAggregator implements ValueAggregator<Double> {
+
+    public static final StarTreeNumericType VALUE_AGGREGATOR_TYPE = StarTreeNumericType.DOUBLE;
+    private double sum = 0;
+    private double compensation = 0;
+    private CompensatedSum kahanSummation = new CompensatedSum(0, 0);
+
+    @Override
+    public MetricStat getAggregationType() {
+        return MetricStat.SUM;
+    }
+
+    @Override
+    public StarTreeNumericType getAggregatedValueType() {
+        return VALUE_AGGREGATOR_TYPE;
+    }
+
+    @Override
+    public Double getInitialAggregatedValueForSegmentDocValue(Long segmentDocValue, StarTreeNumericType starTreeNumericType) {
+        kahanSummation.reset(0, 0);
+        kahanSummation.add(starTreeNumericType.getDoubleValue(segmentDocValue));
+        compensation = kahanSummation.delta();
+        sum = kahanSummation.value();
+        return kahanSummation.value();
+    }
+
+    @Override
+    public Double mergeAggregatedValueAndSegmentValue(Double value, Long segmentDocValue, StarTreeNumericType starTreeNumericType) {
+        assert kahanSummation.value() == value;
+        kahanSummation.reset(sum, compensation);
+        kahanSummation.add(starTreeNumericType.getDoubleValue(segmentDocValue));
+        compensation = kahanSummation.delta();
+        sum = kahanSummation.value();
+        return kahanSummation.value();
+    }
+
+    @Override
+    public Double mergeAggregatedValues(Double value, Double aggregatedValue) {
+        assert kahanSummation.value() == aggregatedValue;
+        kahanSummation.reset(sum, compensation);
+        kahanSummation.add(value);
+        compensation = kahanSummation.delta();
+        sum = kahanSummation.value();
+        return kahanSummation.value();
+    }
+
+    @Override
+    public Double getInitialAggregatedValue(Double value) {
+        kahanSummation.reset(0, 0);
+        kahanSummation.add(value);
+        compensation = kahanSummation.delta();
+        sum = kahanSummation.value();
+        return kahanSummation.value();
+    }
+
+    @Override
+    public int getMaxAggregatedValueByteSize() {
+        return Double.BYTES;
+    }
+
+    @Override
+    public Long toLongValue(Double value) {
+        try {
+            return NumericUtils.doubleToSortableLong(value);
+        } catch (Exception e) {
+            throw new IllegalStateException("Cannot convert " + value + " to sortable long", e);
+        }
+    }
+
+    @Override
+    public Double toStarTreeNumericTypeValue(Long value, StarTreeNumericType type) {
+        try {
+            return type.getDoubleValue(value);
+        } catch (Exception e) {
+            throw new IllegalStateException("Cannot convert " + value + " to sortable aggregation type", e);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregator.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregator.java
new file mode 100644
index 0000000000000..3dd1f85845c17
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregator.java
@@ -0,0 +1,64 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.numerictype.StarTreeNumericType;
+
+/**
+ * A value aggregator that pre-aggregates on the input values for a specific type of aggregation.
+ *
+ * @opensearch.experimental
+ */
+public interface ValueAggregator<A> {
+
+    /**
+     * Returns the type of the aggregation.
+     */
+    MetricStat getAggregationType();
+
+    /**
+     * Returns the data type of the aggregated value.
+     */
+    StarTreeNumericType getAggregatedValueType();
+
+    /**
+     * Returns the initial aggregated value.
+     */
+    A getInitialAggregatedValueForSegmentDocValue(Long segmentDocValue, StarTreeNumericType starTreeNumericType);
+
+    /**
+     * Applies a segment doc value to the current aggregated value.
+     */
+    A mergeAggregatedValueAndSegmentValue(A value, Long segmentDocValue, StarTreeNumericType starTreeNumericType);
+
+    /**
+     * Applies an aggregated value to the current aggregated value.
+     */
+    A mergeAggregatedValues(A value, A aggregatedValue);
+
+    /**
+     * Clones an aggregated value.
+     */
+    A getInitialAggregatedValue(A value);
+
+    /**
+     * Returns the maximum size in bytes of the aggregated values seen so far.
+     */
+    int getMaxAggregatedValueByteSize();
+
+    /**
+     * Converts an aggregated value into a Long type.
+     */
+    Long toLongValue(A value);
+
+    /**
+     * Converts an aggregated value from a Long type.
+     */
+    A toStarTreeNumericTypeValue(Long rawValue, StarTreeNumericType type);
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregatorFactory.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregatorFactory.java
new file mode 100644
index 0000000000000..4ee0b0b5b13f8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregatorFactory.java
@@ -0,0 +1,56 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.numerictype.StarTreeNumericType;
+
+/**
+ * Value aggregator factory for a given aggregation type
+ *
+ * @opensearch.experimental
+ */
+public class ValueAggregatorFactory {
+    private ValueAggregatorFactory() {}
+
+    /**
+     * Returns a new instance of value aggregator for the given aggregation type.
+     *
+     * @param aggregationType Aggregation type
+     * @return Value aggregator
+     */
+    public static ValueAggregator getValueAggregator(MetricStat aggregationType) {
+        switch (aggregationType) {
+            // other metric types (count, min, max, avg) will be supported in the future
+            case SUM:
+                return new SumValueAggregator();
+            case COUNT:
+                return new CountValueAggregator();
+            default:
+                throw new IllegalStateException("Unsupported aggregation type: " + aggregationType);
+        }
+    }
+
+    /**
+     * Returns the data type of the aggregated value for the given aggregation type.
+     *
+     * @param aggregationType Aggregation type
+     * @return Data type of the aggregated value
+     */
+    public static StarTreeNumericType getAggregatedValueType(MetricStat aggregationType) {
+        switch (aggregationType) {
+            // other metric types (count, min, max, avg) will be supported in the future
+            case SUM:
+                return SumValueAggregator.VALUE_AGGREGATOR_TYPE;
+            case COUNT:
+                return CountValueAggregator.VALUE_AGGREGATOR_TYPE;
+            default:
+                throw new IllegalStateException("Unsupported aggregation type: " + aggregationType);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/numerictype/StarTreeNumericType.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/numerictype/StarTreeNumericType.java
new file mode 100644
index 0000000000000..57fe573a6a93c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/numerictype/StarTreeNumericType.java
@@ -0,0 +1,66 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators.numerictype;
+
+import org.opensearch.index.fielddata.IndexNumericFieldData;
+
+import java.util.function.Function;
+
+/**
+ * Enum to map Star Tree Numeric Types to Lucene's Numeric Type
+ *
+ * @opensearch.experimental
+ */
+public enum StarTreeNumericType {
+
+    // TODO: Handle scaled floats
+    HALF_FLOAT(IndexNumericFieldData.NumericType.HALF_FLOAT, StarTreeNumericTypeConverters::halfFloatPointToDouble),
+    FLOAT(IndexNumericFieldData.NumericType.FLOAT, StarTreeNumericTypeConverters::floatPointToDouble),
+    LONG(IndexNumericFieldData.NumericType.LONG, StarTreeNumericTypeConverters::longToDouble),
+    DOUBLE(IndexNumericFieldData.NumericType.DOUBLE, StarTreeNumericTypeConverters::sortableLongtoDouble),
+    INT(IndexNumericFieldData.NumericType.INT, StarTreeNumericTypeConverters::intToDouble),
+    SHORT(IndexNumericFieldData.NumericType.SHORT, StarTreeNumericTypeConverters::shortToDouble),
+    BYTE(IndexNumericFieldData.NumericType.BYTE, StarTreeNumericTypeConverters::bytesToDouble),
+    UNSIGNED_LONG(IndexNumericFieldData.NumericType.UNSIGNED_LONG, StarTreeNumericTypeConverters::unsignedlongToDouble);
+
+    final IndexNumericFieldData.NumericType numericType;
+    final Function<Long, Double> converter;
+
+    StarTreeNumericType(IndexNumericFieldData.NumericType numericType, Function<Long, Double> converter) {
+        this.numericType = numericType;
+        this.converter = converter;
+    }
+
+    public double getDoubleValue(long rawValue) {
+        return this.converter.apply(rawValue);
+    }
+
+    public static StarTreeNumericType fromNumericType(IndexNumericFieldData.NumericType numericType) {
+        switch (numericType) {
+            case HALF_FLOAT:
+                return StarTreeNumericType.HALF_FLOAT;
+            case FLOAT:
+                return StarTreeNumericType.FLOAT;
+            case LONG:
+                return StarTreeNumericType.LONG;
+            case DOUBLE:
+                return StarTreeNumericType.DOUBLE;
+            case INT:
+                return StarTreeNumericType.INT;
+            case SHORT:
+                return StarTreeNumericType.SHORT;
+            case UNSIGNED_LONG:
+                return StarTreeNumericType.UNSIGNED_LONG;
+            case BYTE:
+                return StarTreeNumericType.BYTE;
+            default:
+                throw new UnsupportedOperationException("Unknown numeric type [" + numericType + "]");
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/numerictype/StarTreeNumericTypeConverters.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/numerictype/StarTreeNumericTypeConverters.java
new file mode 100644
index 0000000000000..eb7647c4f9851
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/numerictype/StarTreeNumericTypeConverters.java
@@ -0,0 +1,58 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators.numerictype;
+
+import org.apache.lucene.sandbox.document.HalfFloatPoint;
+import org.apache.lucene.util.NumericUtils;
+import org.opensearch.common.Numbers;
+import org.opensearch.common.annotation.ExperimentalApi;
+
+/**
+ * Numeric converters used during aggregations of metric values
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class StarTreeNumericTypeConverters {
+
+    public static double halfFloatPointToDouble(Long value) {
+        return HalfFloatPoint.sortableShortToHalfFloat((short) value.longValue());
+    }
+
+    public static double floatPointToDouble(Long value) {
+        return NumericUtils.sortableIntToFloat((int) value.longValue());
+    }
+
+    public static double longToDouble(Long value) {
+        return (double) value;
+    }
+
+    public static double intToDouble(Long value) {
+        return (double) value;
+    }
+
+    public static double shortToDouble(Long value) {
+        return (double) value;
+    }
+
+    public static Double sortableLongtoDouble(Long value) {
+        return NumericUtils.sortableLongToDouble(value);
+    }
+
+    public static double unsignedlongToDouble(Long value) {
+        return Numbers.unsignedLongToDouble(value);
+    }
+
+    public static double bytesToDouble(Long value) {
+        byte[] bytes = new byte[8];
+        NumericUtils.longToSortableBytes(value, bytes, 0);
+        return NumericUtils.sortableLongToDouble(NumericUtils.sortableBytesToLong(bytes, 0));
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/numerictype/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/numerictype/package-info.java
new file mode 100644
index 0000000000000..fe5c2a7ceb254
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/numerictype/package-info.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Numeric Types for Composite Index Star Tree
+ *
+ *  @opensearch.experimental
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators.numerictype;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/package-info.java
new file mode 100644
index 0000000000000..bddd6a46fbbe8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/package-info.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Aggregators for Composite Index Star Tree
+ *
+ * @opensearch.experimental
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilder.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilder.java
new file mode 100644
index 0000000000000..0a363bfad8fe1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilder.java
@@ -0,0 +1,668 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.SegmentWriteState;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeDocument;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.MetricAggregatorInfo;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.ValueAggregator;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.numerictype.StarTreeNumericType;
+import org.opensearch.index.compositeindex.datacube.startree.utils.SequentialDocValuesIterator;
+import org.opensearch.index.compositeindex.datacube.startree.utils.TreeNode;
+import org.opensearch.index.fielddata.IndexNumericFieldData;
+import org.opensearch.index.mapper.Mapper;
+import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.mapper.NumberFieldMapper;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.opensearch.index.compositeindex.datacube.startree.utils.TreeNode.ALL;
+
+/**
+ * Builder for star tree. Defines the algorithm to construct star-tree
+ * See {@link StarTreesBuilder} for information around the construction of star-trees based on star-tree fields
+ *
+ * @opensearch.experimental
+ */
+public abstract class BaseStarTreeBuilder implements StarTreeBuilder {
+
+    private static final Logger logger = LogManager.getLogger(BaseStarTreeBuilder.class);
+
+    /**
+     * Default value for star node
+     */
+    public static final int STAR_IN_DOC_VALUES_INDEX = -1;
+
+    protected final Set<Integer> skipStarNodeCreationForDimensions;
+
+    protected final List<MetricAggregatorInfo> metricAggregatorInfos;
+    protected final int numMetrics;
+    protected final int numDimensions;
+    protected int numStarTreeDocs;
+    protected int totalSegmentDocs;
+    protected int numStarTreeNodes;
+    protected final int maxLeafDocuments;
+
+    protected final TreeNode rootNode = getNewNode();
+
+    protected SequentialDocValuesIterator[] dimensionReaders;
+
+    // We do not close these producers as they are empty doc value producers (where close() is unsupported)
+    protected Map<String, DocValuesProducer> fieldProducerMap;
+
+    private final StarTreeDocValuesIteratorAdapter starTreeDocValuesIteratorAdapter;
+    private final StarTreeField starTreeField;
+
+    /**
+     * Reads all the configuration related to dimensions and metrics, builds a star-tree based on the different construction parameters.
+     *
+     * @param starTreeField    holds the configuration for the star tree
+     * @param fieldProducerMap helps return the doc values iterator for each type based on field name
+     * @param state            stores the segment write state
+     * @param mapperService    helps to find the original type of the field
+     */
+    protected BaseStarTreeBuilder(
+        StarTreeField starTreeField,
+        Map<String, DocValuesProducer> fieldProducerMap,
+        SegmentWriteState state,
+        MapperService mapperService
+    ) throws IOException {
+
+        logger.debug("Building in base star tree builder");
+
+        this.starTreeField = starTreeField;
+        StarTreeFieldConfiguration starTreeFieldSpec = starTreeField.getStarTreeConfig();
+        this.fieldProducerMap = fieldProducerMap;
+        this.starTreeDocValuesIteratorAdapter = new StarTreeDocValuesIteratorAdapter();
+
+        List<Dimension> dimensionsSplitOrder = starTreeField.getDimensionsOrder();
+        this.numDimensions = dimensionsSplitOrder.size();
+
+        this.skipStarNodeCreationForDimensions = new HashSet<>();
+        this.totalSegmentDocs = state.segmentInfo.maxDoc();
+        this.dimensionReaders = new SequentialDocValuesIterator[numDimensions];
+        Set<String> skipStarNodeCreationForDimensions = starTreeFieldSpec.getSkipStarNodeCreationInDims();
+
+        for (int i = 0; i < numDimensions; i++) {
+            String dimension = dimensionsSplitOrder.get(i).getField();
+            if (skipStarNodeCreationForDimensions.contains(dimensionsSplitOrder.get(i).getField())) {
+                this.skipStarNodeCreationForDimensions.add(i);
+            }
+            FieldInfo dimensionFieldInfos = state.fieldInfos.fieldInfo(dimension);
+            DocValuesType dimensionDocValuesType = dimensionFieldInfos.getDocValuesType();
+            dimensionReaders[i] = starTreeDocValuesIteratorAdapter.getDocValuesIterator(
+                dimensionDocValuesType,
+                dimensionFieldInfos,
+                fieldProducerMap.get(dimensionFieldInfos.name)
+            );
+        }
+
+        this.metricAggregatorInfos = generateMetricAggregatorInfos(mapperService, state);
+        this.numMetrics = metricAggregatorInfos.size();
+        this.maxLeafDocuments = starTreeFieldSpec.maxLeafDocs();
+    }
+
+    /**
+     * Generates the configuration required to perform aggregation for all the metrics on a field
+     *
+     * @return list of MetricAggregatorInfo
+     */
+    public List<MetricAggregatorInfo> generateMetricAggregatorInfos(MapperService mapperService, SegmentWriteState state)
+        throws IOException {
+        List<MetricAggregatorInfo> metricAggregatorInfos = new ArrayList<>();
+        for (Metric metric : this.starTreeField.getMetrics()) {
+            for (MetricStat metricStat : metric.getMetrics()) {
+                IndexNumericFieldData.NumericType numericType;
+                SequentialDocValuesIterator metricStatReader;
+                Mapper fieldMapper = mapperService.documentMapper().mappers().getMapper(metric.getField());
+                if (fieldMapper instanceof NumberFieldMapper) {
+                    numericType = ((NumberFieldMapper) fieldMapper).fieldType().numericType();
+                } else {
+                    logger.error("unsupported mapper type");
+                    throw new IllegalStateException("unsupported mapper type");
+                }
+
+                FieldInfo metricFieldInfos = state.fieldInfos.fieldInfo(metric.getField());
+                DocValuesType metricDocValuesType = metricFieldInfos.getDocValuesType();
+                if (metricStat != MetricStat.COUNT) {
+                    metricStatReader = starTreeDocValuesIteratorAdapter.getDocValuesIterator(
+                        metricDocValuesType,
+                        metricFieldInfos,
+                        fieldProducerMap.get(metricFieldInfos.name)
+                    );
+                } else {
+                    metricStatReader = new SequentialDocValuesIterator();
+                }
+
+                MetricAggregatorInfo metricAggregatorInfo = new MetricAggregatorInfo(
+                    metricStat,
+                    metric.getField(),
+                    starTreeField.getName(),
+                    numericType,
+                    metricStatReader
+                );
+                metricAggregatorInfos.add(metricAggregatorInfo);
+            }
+        }
+        return metricAggregatorInfos;
+    }
+
+    /**
+     * Adds a document to the star-tree.
+     *
+     * @param starTreeDocument star tree document to be added
+     * @throws IOException if an I/O error occurs while adding the document
+     */
+    public abstract void appendStarTreeDocument(StarTreeDocument starTreeDocument) throws IOException;
+
+    /**
+     * Returns the document of the given document id in the star-tree.
+     *
+     * @param docId document id
+     * @return star tree document
+     * @throws IOException if an I/O error occurs while fetching the star-tree document
+     */
+    public abstract StarTreeDocument getStarTreeDocument(int docId) throws IOException;
+
+    /**
+     * Retrieves the list of star-tree documents in the star-tree.
+     *
+     * @return Star tree documents
+     */
+    public abstract List<StarTreeDocument> getStarTreeDocuments();
+
+    /**
+     * Returns the value of the dimension for the given dimension id and document in the star-tree.
+     *
+     * @param docId       document id
+     * @param dimensionId dimension id
+     * @return dimension value
+     */
+    public abstract Long getDimensionValue(int docId, int dimensionId) throws IOException;
+
+    /**
+     * Sorts and aggregates the star-tree document in the segment, and returns a star-tree document iterator for all the
+     * aggregated star-tree document.
+     *
+     * @return Iterator for the aggregated star-tree document
+     */
+    public abstract Iterator<StarTreeDocument> sortAndAggregateStarTreeDocuments() throws IOException;
+
+    /**
+     * Generates aggregated star-tree documents for star-node.
+     *
+     * @param startDocId  start document id (inclusive) in the star-tree
+     * @param endDocId    end document id (exclusive) in the star-tree
+     * @param dimensionId dimension id of the star-node
+     * @return Iterator for the aggregated star-tree documents
+     */
+    public abstract Iterator<StarTreeDocument> generateStarTreeDocumentsForStarNode(int startDocId, int endDocId, int dimensionId)
+        throws IOException;
+
+    /**
+     * Returns the star-tree document from the segment
+     *
+     * @throws IOException when we are unable to build a star tree document from the segment
+     */
+    protected StarTreeDocument getSegmentStarTreeDocument(int currentDocId) throws IOException {
+        Long[] dimensions = getStarTreeDimensionsFromSegment(currentDocId);
+        Object[] metrics = getStarTreeMetricsFromSegment(currentDocId);
+        return new StarTreeDocument(dimensions, metrics);
+    }
+
+    /**
+     * Returns the dimension values for the next document from the segment
+     *
+     * @return dimension values for each of the star-tree dimension
+     * @throws IOException when we are unable to iterate to the next doc for the given dimension readers
+     */
+    private Long[] getStarTreeDimensionsFromSegment(int currentDocId) throws IOException {
+        Long[] dimensions = new Long[numDimensions];
+        for (int i = 0; i < numDimensions; i++) {
+            try {
+                dimensions[i] = getValuesFromSegment(dimensionReaders[i], currentDocId);
+            } catch (Exception e) {
+                logger.error("unable to read the dimension values from the segment", e);
+                throw new IllegalStateException("unable to read the dimension values from the segment", e);
+            }
+
+        }
+        return dimensions;
+    }
+
+    /**
+     * Returns the next value from the iterator of respective field
+     *
+     * @param iterator     respective field iterator
+     * @param currentDocId current document id
+     * @return the next value for the field
+     * @throws IOException when we are unable to iterate to the next doc for the given iterator
+     */
+    private Long getValuesFromSegment(SequentialDocValuesIterator iterator, int currentDocId) throws IOException {
+        try {
+            starTreeDocValuesIteratorAdapter.nextDoc(iterator, currentDocId);
+        } catch (IOException e) {
+            logger.error("unable to iterate to next doc", e);
+            throw new RuntimeException("unable to iterate to next doc", e);
+        }
+        return starTreeDocValuesIteratorAdapter.getNextValue(iterator, currentDocId);
+    }
+
+    /**
+     * Returns the metric values for the next document from the segment
+     *
+     * @return metric values for each of the star-tree metric
+     * @throws IOException when we are unable to iterate to the next doc for the given metric readers
+     */
+    private Object[] getStarTreeMetricsFromSegment(int currentDocId) throws IOException {
+        Object[] metrics = new Object[numMetrics];
+        for (int i = 0; i < numMetrics; i++) {
+            SequentialDocValuesIterator metricStatReader = metricAggregatorInfos.get(i).getMetricStatReader();
+            if (metricStatReader != null) {
+                try {
+                    metrics[i] = getValuesFromSegment(metricStatReader, currentDocId);
+                } catch (Exception e) {
+                    logger.error("unable to read the metric values from the segment", e);
+                    throw new IllegalStateException("unable to read the metric values from the segment", e);
+                }
+            } else {
+                throw new IllegalStateException("metric readers are empty");
+            }
+        }
+        return metrics;
+    }
+
+    /**
+     * Merges a star-tree document from the segment into an aggregated star-tree document.
+     * A new aggregated star-tree document is created if the aggregated segment document is null.
+     *
+     * @param aggregatedSegmentDocument aggregated star-tree document
+     * @param segmentDocument           segment star-tree document
+     * @return merged star-tree document
+     */
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    protected StarTreeDocument reduceSegmentStarTreeDocuments(
+        StarTreeDocument aggregatedSegmentDocument,
+        StarTreeDocument segmentDocument
+    ) {
+        if (aggregatedSegmentDocument == null) {
+            Long[] dimensions = Arrays.copyOf(segmentDocument.dimensions, numDimensions);
+            Object[] metrics = new Object[numMetrics];
+            for (int i = 0; i < numMetrics; i++) {
+                try {
+                    ValueAggregator metricValueAggregator = metricAggregatorInfos.get(i).getValueAggregators();
+                    StarTreeNumericType starTreeNumericType = metricAggregatorInfos.get(i).getAggregatedValueType();
+                    metrics[i] = metricValueAggregator.getInitialAggregatedValueForSegmentDocValue(
+                        getLong(segmentDocument.metrics[i]),
+                        starTreeNumericType
+                    );
+                } catch (Exception e) {
+                    logger.error("Cannot parse initial segment doc value", e);
+                    throw new IllegalStateException("Cannot parse initial segment doc value [" + segmentDocument.metrics[i] + "]");
+                }
+            }
+            return new StarTreeDocument(dimensions, metrics);
+        } else {
+            for (int i = 0; i < numMetrics; i++) {
+                try {
+                    ValueAggregator metricValueAggregator = metricAggregatorInfos.get(i).getValueAggregators();
+                    StarTreeNumericType starTreeNumericType = metricAggregatorInfos.get(i).getAggregatedValueType();
+                    aggregatedSegmentDocument.metrics[i] = metricValueAggregator.mergeAggregatedValueAndSegmentValue(
+                        aggregatedSegmentDocument.metrics[i],
+                        getLong(segmentDocument.metrics[i]),
+                        starTreeNumericType
+                    );
+                } catch (Exception e) {
+                    logger.error("Cannot apply segment doc value for aggregation", e);
+                    throw new IllegalStateException("Cannot apply segment doc value for aggregation [" + segmentDocument.metrics[i] + "]");
+                }
+            }
+            return aggregatedSegmentDocument;
+        }
+    }
+
+    /**
+     * Safely converts the metric value of object type to long.
+     *
+     * @param metric value of the metric
+     * @return converted metric value to long
+     */
+    private static long getLong(Object metric) {
+
+        Long metricValue = null;
+        try {
+            if (metric instanceof Long) {
+                metricValue = (long) metric;
+            } else if (metric != null) {
+                metricValue = Long.valueOf(String.valueOf(metric));
+            }
+        } catch (Exception e) {
+            throw new IllegalStateException("unable to cast segment metric", e);
+        }
+
+        if (metricValue == null) {
+            throw new IllegalStateException("unable to cast segment metric");
+        }
+        return metricValue;
+    }
+
+    /**
+     * Merges a star-tree document into an aggregated star-tree document.
+     * A new aggregated star-tree document is created if the aggregated document is null.
+     *
+     * @param aggregatedDocument aggregated star-tree document
+     * @param starTreeDocument   segment star-tree document
+     * @return merged star-tree document
+     */
+    @SuppressWarnings("unchecked")
+    public StarTreeDocument reduceStarTreeDocuments(StarTreeDocument aggregatedDocument, StarTreeDocument starTreeDocument) {
+        // aggregate the documents
+        if (aggregatedDocument == null) {
+            Long[] dimensions = Arrays.copyOf(starTreeDocument.dimensions, numDimensions);
+            Object[] metrics = new Object[numMetrics];
+            for (int i = 0; i < numMetrics; i++) {
+                try {
+                    metrics[i] = metricAggregatorInfos.get(i).getValueAggregators().getInitialAggregatedValue(starTreeDocument.metrics[i]);
+                } catch (Exception e) {
+                    logger.error("Cannot get value for aggregation", e);
+                    throw new IllegalStateException("Cannot get value for aggregation[" + starTreeDocument.metrics[i] + "]");
+                }
+            }
+            return new StarTreeDocument(dimensions, metrics);
+        } else {
+            for (int i = 0; i < numMetrics; i++) {
+                try {
+                    aggregatedDocument.metrics[i] = metricAggregatorInfos.get(i)
+                        .getValueAggregators()
+                        .mergeAggregatedValues(starTreeDocument.metrics[i], aggregatedDocument.metrics[i]);
+                } catch (Exception e) {
+                    logger.error("Cannot apply value to aggregated document for aggregation", e);
+                    throw new IllegalStateException(
+                        "Cannot apply value to aggregated document for aggregation [" + starTreeDocument.metrics[i] + "]"
+                    );
+                }
+            }
+            return aggregatedDocument;
+        }
+    }
+
+    /**
+     * Builds the star tree using total segment documents
+     *
+     * @throws IOException when we are unable to build star-tree
+     */
+    public void build() throws IOException {
+        long startTime = System.currentTimeMillis();
+        logger.debug("Star-tree build is a go with star tree field {}", starTreeField.getName());
+
+        if (totalSegmentDocs == 0) {
+            logger.debug("No documents found in the segment");
+            return;
+        }
+
+        Iterator<StarTreeDocument> starTreeDocumentIterator = sortAndAggregateStarTreeDocuments();
+        logger.debug("Sorting and aggregating star-tree in ms : {}", (System.currentTimeMillis() - startTime));
+        build(starTreeDocumentIterator);
+        logger.debug("Finished Building star-tree in ms : {}", (System.currentTimeMillis() - startTime));
+    }
+
+    /**
+     * Builds the star tree using Star-Tree Document
+     *
+     * @param starTreeDocumentIterator contains the sorted and aggregated documents
+     * @throws IOException when we are unable to build star-tree
+     */
+    void build(Iterator<StarTreeDocument> starTreeDocumentIterator) throws IOException {
+        int numSegmentStarTreeDocument = totalSegmentDocs;
+
+        while (starTreeDocumentIterator.hasNext()) {
+            appendToStarTree(starTreeDocumentIterator.next());
+        }
+        int numStarTreeDocument = numStarTreeDocs;
+        logger.debug("Generated star tree docs : [{}] from segment docs : [{}]", numStarTreeDocument, numSegmentStarTreeDocument);
+
+        if (numStarTreeDocs == 0) {
+            // TODO: Uncomment when segment codec and file formats is ready
+            // StarTreeBuilderUtils.serializeTree(indexOutput, rootNode, dimensionsSplitOrder, numNodes);
+            return;
+        }
+
+        constructStarTree(rootNode, 0, numStarTreeDocs);
+        int numStarTreeDocumentUnderStarNode = numStarTreeDocs - numStarTreeDocument;
+        logger.debug(
+            "Finished constructing star-tree, got [ {} ] tree nodes and [ {} ] starTreeDocument under star-node",
+            numStarTreeNodes,
+            numStarTreeDocumentUnderStarNode
+        );
+
+        createAggregatedDocs(rootNode);
+        int numAggregatedStarTreeDocument = numStarTreeDocs - numStarTreeDocument - numStarTreeDocumentUnderStarNode;
+        logger.debug("Finished creating aggregated documents : {}", numAggregatedStarTreeDocument);
+
+        // TODO: When StarTree Codec is ready
+        // Create doc values indices in disk
+        // Serialize and save in disk
+        // Write star tree metadata for off heap implementation
+
+    }
+
+    /**
+     * Adds a document to star-tree
+     *
+     * @param starTreeDocument star-tree document
+     * @throws IOException throws an exception if we are unable to add the doc
+     */
+    private void appendToStarTree(StarTreeDocument starTreeDocument) throws IOException {
+        appendStarTreeDocument(starTreeDocument);
+        numStarTreeDocs++;
+    }
+
+    /**
+     * Returns a new star-tree node
+     *
+     * @return return new star-tree node
+     */
+    private TreeNode getNewNode() {
+        numStarTreeNodes++;
+        return new TreeNode();
+    }
+
+    /**
+     * Implements the algorithm to construct a star-tree
+     *
+     * @param node       star-tree node
+     * @param startDocId start document id
+     * @param endDocId   end document id
+     * @throws IOException throws an exception if we are unable to construct the tree
+     */
+    private void constructStarTree(TreeNode node, int startDocId, int endDocId) throws IOException {
+
+        int childDimensionId = node.dimensionId + 1;
+        if (childDimensionId == numDimensions) {
+            return;
+        }
+
+        // Construct all non-star children nodes
+        node.childDimensionId = childDimensionId;
+        Map<Long, TreeNode> children = constructNonStarNodes(startDocId, endDocId, childDimensionId);
+        node.children = children;
+
+        // Construct star-node if required
+        if (!skipStarNodeCreationForDimensions.contains(childDimensionId) && children.size() > 1) {
+            children.put((long) ALL, constructStarNode(startDocId, endDocId, childDimensionId));
+        }
+
+        // Further split on child nodes if required
+        for (TreeNode child : children.values()) {
+            if (child.endDocId - child.startDocId > maxLeafDocuments) {
+                constructStarTree(child, child.startDocId, child.endDocId);
+            }
+        }
+    }
+
+    /**
+     * Constructs non star tree nodes
+     *
+     * @param startDocId  start document id (inclusive)
+     * @param endDocId    end document id (exclusive)
+     * @param dimensionId id of the dimension in the star tree
+     * @return root node with non-star nodes constructed
+     * @throws IOException throws an exception if we are unable to construct non-star nodes
+     */
+    private Map<Long, TreeNode> constructNonStarNodes(int startDocId, int endDocId, int dimensionId) throws IOException {
+        Map<Long, TreeNode> nodes = new HashMap<>();
+        int nodeStartDocId = startDocId;
+        Long nodeDimensionValue = getDimensionValue(startDocId, dimensionId);
+        for (int i = startDocId + 1; i < endDocId; i++) {
+            Long dimensionValue = getDimensionValue(i, dimensionId);
+            if (!dimensionValue.equals(nodeDimensionValue)) {
+                TreeNode child = getNewNode();
+                child.dimensionId = dimensionId;
+                child.dimensionValue = nodeDimensionValue;
+                child.startDocId = nodeStartDocId;
+                child.endDocId = i;
+                nodes.put(nodeDimensionValue, child);
+
+                nodeStartDocId = i;
+                nodeDimensionValue = dimensionValue;
+            }
+        }
+        TreeNode lastNode = getNewNode();
+        lastNode.dimensionId = dimensionId;
+        lastNode.dimensionValue = nodeDimensionValue;
+        lastNode.startDocId = nodeStartDocId;
+        lastNode.endDocId = endDocId;
+        nodes.put(nodeDimensionValue, lastNode);
+        return nodes;
+    }
+
+    /**
+     * Constructs star tree nodes
+     *
+     * @param startDocId  start document id (inclusive)
+     * @param endDocId    end document id (exclusive)
+     * @param dimensionId id of the dimension in the star tree
+     * @return root node with star nodes constructed
+     * @throws IOException throws an exception if we are unable to construct non-star nodes
+     */
+    private TreeNode constructStarNode(int startDocId, int endDocId, int dimensionId) throws IOException {
+        TreeNode starNode = getNewNode();
+        starNode.dimensionId = dimensionId;
+        starNode.dimensionValue = ALL;
+        starNode.isStarNode = true;
+        starNode.startDocId = numStarTreeDocs;
+        Iterator<StarTreeDocument> starTreeDocumentIterator = generateStarTreeDocumentsForStarNode(startDocId, endDocId, dimensionId);
+        while (starTreeDocumentIterator.hasNext()) {
+            appendToStarTree(starTreeDocumentIterator.next());
+        }
+        starNode.endDocId = numStarTreeDocs;
+        return starNode;
+    }
+
+    /**
+     * Returns aggregated star-tree document
+     *
+     * @param node star-tree node
+     * @return aggregated star-tree documents
+     * @throws IOException throws an exception upon failing to create new aggregated docs based on star tree
+     */
+    private StarTreeDocument createAggregatedDocs(TreeNode node) throws IOException {
+        StarTreeDocument aggregatedStarTreeDocument = null;
+        if (node.children == null) {
+
+            // For leaf node
+            if (node.startDocId == node.endDocId - 1) {
+                // If it has only one document, use it as the aggregated document
+                aggregatedStarTreeDocument = getStarTreeDocument(node.startDocId);
+                node.aggregatedDocId = node.startDocId;
+            } else {
+                // If it has multiple documents, aggregate all of them
+                for (int i = node.startDocId; i < node.endDocId; i++) {
+                    aggregatedStarTreeDocument = reduceStarTreeDocuments(aggregatedStarTreeDocument, getStarTreeDocument(i));
+                }
+                if (null == aggregatedStarTreeDocument) {
+                    throw new IllegalStateException("aggregated star-tree document is null after reducing the documents");
+                }
+                for (int i = node.dimensionId + 1; i < numDimensions; i++) {
+                    aggregatedStarTreeDocument.dimensions[i] = Long.valueOf(STAR_IN_DOC_VALUES_INDEX);
+                }
+                node.aggregatedDocId = numStarTreeDocs;
+                appendToStarTree(aggregatedStarTreeDocument);
+            }
+        } else {
+            // For non-leaf node
+            if (node.children.containsKey((long) ALL)) {
+                // If it has star child, use the star child aggregated document directly
+                for (TreeNode child : node.children.values()) {
+                    if (child.isStarNode) {
+                        aggregatedStarTreeDocument = createAggregatedDocs(child);
+                        node.aggregatedDocId = child.aggregatedDocId;
+                    } else {
+                        createAggregatedDocs(child);
+                    }
+                }
+            } else {
+                // If no star child exists, aggregate all aggregated documents from non-star children
+                if (node.children.values().size() == 1) {
+                    for (TreeNode child : node.children.values()) {
+                        aggregatedStarTreeDocument = reduceStarTreeDocuments(aggregatedStarTreeDocument, createAggregatedDocs(child));
+                        node.aggregatedDocId = child.aggregatedDocId;
+                    }
+                } else {
+                    for (TreeNode child : node.children.values()) {
+                        aggregatedStarTreeDocument = reduceStarTreeDocuments(aggregatedStarTreeDocument, createAggregatedDocs(child));
+                    }
+                    if (null == aggregatedStarTreeDocument) {
+                        throw new IllegalStateException("aggregated star-tree document is null after reducing the documents");
+                    }
+                    for (int i = node.dimensionId + 1; i < numDimensions; i++) {
+                        aggregatedStarTreeDocument.dimensions[i] = Long.valueOf(STAR_IN_DOC_VALUES_INDEX);
+                    }
+                    node.aggregatedDocId = numStarTreeDocs;
+                    appendToStarTree(aggregatedStarTreeDocument);
+                }
+            }
+        }
+        return aggregatedStarTreeDocument;
+    }
+
+    /**
+     * Handles the dimension of date time field type
+     *
+     * @param fieldName name of the field
+     * @param val       value of the field
+     * @return returns the converted dimension of the field to a particular granularity
+     */
+    private long handleDateDimension(final String fieldName, final long val) {
+        // TODO: handle timestamp granularity
+        return val;
+    }
+
+    public void close() throws IOException {
+
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilder.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilder.java
new file mode 100644
index 0000000000000..caeb24838da62
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilder.java
@@ -0,0 +1,213 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.index.SegmentWriteState;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeDocument;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.mapper.MapperService;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * On heap single tree builder
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class OnHeapStarTreeBuilder extends BaseStarTreeBuilder {
+
+    private final List<StarTreeDocument> starTreeDocuments = new ArrayList<>();
+
+    /**
+     * Constructor for OnHeapStarTreeBuilder
+     *
+     * @param starTreeField     star-tree field
+     * @param fieldProducerMap  helps with document values producer for a particular field
+     * @param segmentWriteState segment write state
+     * @param mapperService     helps with the numeric type of field
+     * @throws IOException throws an exception we are unable to construct an onheap star-tree
+     */
+    public OnHeapStarTreeBuilder(
+        StarTreeField starTreeField,
+        Map<String, DocValuesProducer> fieldProducerMap,
+        SegmentWriteState segmentWriteState,
+        MapperService mapperService
+    ) throws IOException {
+        super(starTreeField, fieldProducerMap, segmentWriteState, mapperService);
+    }
+
+    @Override
+    public void appendStarTreeDocument(StarTreeDocument starTreeDocument) throws IOException {
+        starTreeDocuments.add(starTreeDocument);
+    }
+
+    @Override
+    public StarTreeDocument getStarTreeDocument(int docId) throws IOException {
+        return starTreeDocuments.get(docId);
+    }
+
+    @Override
+    public List<StarTreeDocument> getStarTreeDocuments() {
+        return starTreeDocuments;
+    }
+
+    @Override
+    public Long getDimensionValue(int docId, int dimensionId) throws IOException {
+        return starTreeDocuments.get(docId).dimensions[dimensionId];
+    }
+
+    @Override
+    public Iterator<StarTreeDocument> sortAndAggregateStarTreeDocuments() throws IOException {
+        int numDocs = totalSegmentDocs;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[numDocs];
+        for (int currentDocId = 0; currentDocId < numDocs; currentDocId++) {
+            starTreeDocuments[currentDocId] = getSegmentStarTreeDocument(currentDocId);
+        }
+
+        return sortAndAggregateStarTreeDocuments(starTreeDocuments);
+    }
+
+    /**
+     * Sort, aggregates and merges the star-tree documents
+     *
+     * @param starTreeDocuments star-tree documents
+     * @return iterator for star-tree documents
+     */
+    Iterator<StarTreeDocument> sortAndAggregateStarTreeDocuments(StarTreeDocument[] starTreeDocuments) {
+
+        // sort all the documents
+        sortStarTreeDocumentsFromDimensionId(starTreeDocuments, 0);
+
+        // merge the documents
+        return mergeStarTreeDocuments(starTreeDocuments);
+    }
+
+    /**
+     * Merges the star-tree documents
+     *
+     * @param starTreeDocuments star-tree documents
+     * @return iterator to aggregate star-tree documents
+     */
+    private Iterator<StarTreeDocument> mergeStarTreeDocuments(StarTreeDocument[] starTreeDocuments) {
+        return new Iterator<>() {
+            boolean hasNext = true;
+            StarTreeDocument currentStarTreeDocument = starTreeDocuments[0];
+            // starting from 1 since we have already fetched the 0th document
+            int docId = 1;
+
+            @Override
+            public boolean hasNext() {
+                return hasNext;
+            }
+
+            @Override
+            public StarTreeDocument next() {
+                // aggregate as we move on to the next doc
+                StarTreeDocument next = reduceSegmentStarTreeDocuments(null, currentStarTreeDocument);
+                while (docId < starTreeDocuments.length) {
+                    StarTreeDocument starTreeDocument = starTreeDocuments[docId];
+                    docId++;
+                    if (Arrays.equals(starTreeDocument.dimensions, next.dimensions) == false) {
+                        currentStarTreeDocument = starTreeDocument;
+                        return next;
+                    } else {
+                        next = reduceSegmentStarTreeDocuments(next, starTreeDocument);
+                    }
+                }
+                hasNext = false;
+                return next;
+            }
+        };
+    }
+
+    /**
+     * Generates a star-tree for a given star-node
+     *
+     * @param startDocId  Start document id in the star-tree
+     * @param endDocId    End document id (exclusive) in the star-tree
+     * @param dimensionId Dimension id of the star-node
+     * @return iterator for star-tree documents of star-node
+     * @throws IOException throws when unable to generate star-tree for star-node
+     */
+    @Override
+    public Iterator<StarTreeDocument> generateStarTreeDocumentsForStarNode(int startDocId, int endDocId, int dimensionId)
+        throws IOException {
+        int numDocs = endDocId - startDocId;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[numDocs];
+        for (int i = 0; i < numDocs; i++) {
+            starTreeDocuments[i] = getStarTreeDocument(startDocId + i);
+        }
+
+        // sort star tree documents from given dimension id (as previous dimension ids have already been processed)
+        sortStarTreeDocumentsFromDimensionId(starTreeDocuments, dimensionId + 1);
+
+        return new Iterator<StarTreeDocument>() {
+            boolean hasNext = true;
+            StarTreeDocument currentStarTreeDocument = starTreeDocuments[0];
+            int docId = 1;
+
+            private boolean hasSameDimensions(StarTreeDocument starTreeDocument1, StarTreeDocument starTreeDocument2) {
+                for (int i = dimensionId + 1; i < numDimensions; i++) {
+                    if (!Objects.equals(starTreeDocument1.dimensions[i], starTreeDocument2.dimensions[i])) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            @Override
+            public boolean hasNext() {
+                return hasNext;
+            }
+
+            @Override
+            public StarTreeDocument next() {
+                StarTreeDocument next = reduceStarTreeDocuments(null, currentStarTreeDocument);
+                next.dimensions[dimensionId] = Long.valueOf(STAR_IN_DOC_VALUES_INDEX);
+                while (docId < numDocs) {
+                    StarTreeDocument starTreeDocument = starTreeDocuments[docId];
+                    docId++;
+                    if (!hasSameDimensions(starTreeDocument, currentStarTreeDocument)) {
+                        currentStarTreeDocument = starTreeDocument;
+                        return next;
+                    } else {
+                        next = reduceStarTreeDocuments(next, starTreeDocument);
+                    }
+                }
+                hasNext = false;
+                return next;
+            }
+        };
+    }
+
+    /**
+     * Sorts the star-tree documents from the given dimension id
+     *
+     * @param starTreeDocuments star-tree documents
+     * @param dimensionId id of the dimension
+     */
+    private void sortStarTreeDocumentsFromDimensionId(StarTreeDocument[] starTreeDocuments, int dimensionId) {
+        Arrays.sort(starTreeDocuments, (o1, o2) -> {
+            for (int i = dimensionId; i < numDimensions; i++) {
+                if (!Objects.equals(o1.dimensions[i], o2.dimensions[i])) {
+                    return Long.compare(o1.dimensions[i], o2.dimensions[i]);
+                }
+            }
+            return 0;
+        });
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeBuilder.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeBuilder.java
new file mode 100644
index 0000000000000..20af1b3bc7935
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeBuilder.java
@@ -0,0 +1,29 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.io.Closeable;
+import java.io.IOException;
+
+/**
+ * A star-tree builder that builds a single star-tree.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public interface StarTreeBuilder extends Closeable {
+
+    /**
+     * Builds the star tree based on star-tree field
+     * @throws IOException when we are unable to build star-tree
+     */
+    void build() throws IOException;
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeDocValuesIteratorAdapter.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeDocValuesIteratorAdapter.java
new file mode 100644
index 0000000000000..cb0350bb110b0
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeDocValuesIteratorAdapter.java
@@ -0,0 +1,82 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.search.DocIdSetIterator;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.compositeindex.datacube.startree.utils.SequentialDocValuesIterator;
+
+import java.io.IOException;
+
+/**
+ * A factory class to return respective doc values iterator based on the doc volues type.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class StarTreeDocValuesIteratorAdapter {
+
+    /**
+     * Creates an iterator for the given doc values type and field using the doc values producer
+     */
+    public SequentialDocValuesIterator getDocValuesIterator(DocValuesType type, FieldInfo field, DocValuesProducer producer)
+        throws IOException {
+        switch (type) {
+            case SORTED_NUMERIC:
+                return new SequentialDocValuesIterator(producer.getSortedNumeric(field));
+            default:
+                throw new IllegalArgumentException("Unsupported DocValuesType: " + type);
+        }
+    }
+
+    /**
+     * Returns the next value for the given iterator
+     */
+    public Long getNextValue(SequentialDocValuesIterator sequentialDocValuesIterator, int currentDocId) throws IOException {
+        if (sequentialDocValuesIterator.getDocIdSetIterator() instanceof SortedNumericDocValues) {
+            SortedNumericDocValues sortedNumericDocValues = (SortedNumericDocValues) sequentialDocValuesIterator.getDocIdSetIterator();
+            if (sequentialDocValuesIterator.getDocId() < 0 || sequentialDocValuesIterator.getDocId() == DocIdSetIterator.NO_MORE_DOCS) {
+                throw new IllegalStateException("invalid doc id to fetch the next value");
+            }
+
+            if (sequentialDocValuesIterator.getDocValue() == null) {
+                sequentialDocValuesIterator.setDocValue(sortedNumericDocValues.nextValue());
+                return sequentialDocValuesIterator.getDocValue();
+            }
+
+            if (sequentialDocValuesIterator.getDocId() == currentDocId) {
+                Long nextValue = sequentialDocValuesIterator.getDocValue();
+                sequentialDocValuesIterator.setDocValue(null);
+                return nextValue;
+            } else {
+                return null;
+            }
+        } else {
+            throw new IllegalStateException("Unsupported Iterator: " + sequentialDocValuesIterator.getDocIdSetIterator().toString());
+        }
+    }
+
+    /**
+     * Moves to the next doc in the iterator
+     * Returns the doc id for the next document from the given iterator
+     */
+    public int nextDoc(SequentialDocValuesIterator iterator, int currentDocId) throws IOException {
+        if (iterator.getDocValue() != null) {
+            return iterator.getDocId();
+        }
+        iterator.setDocId(iterator.getDocIdSetIterator().nextDoc());
+        iterator.setDocValue(this.getNextValue(iterator, currentDocId));
+        return iterator.getDocId();
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreesBuilder.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreesBuilder.java
new file mode 100644
index 0000000000000..eaf9ae1dcdaa1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreesBuilder.java
@@ -0,0 +1,114 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.index.SegmentWriteState;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.mapper.CompositeMappedFieldType;
+import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.mapper.StarTreeMapper;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+/**
+ * Builder to construct star-trees based on multiple star-tree fields.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class StarTreesBuilder implements Closeable {
+
+    private static final Logger logger = LogManager.getLogger(StarTreesBuilder.class);
+
+    private final List<StarTreeField> starTreeFields;
+    private final SegmentWriteState state;
+    private final Map<String, DocValuesProducer> fieldProducerMap;
+    private final MapperService mapperService;
+
+    public StarTreesBuilder(
+        Map<String, DocValuesProducer> fieldProducerMap,
+        SegmentWriteState segmentWriteState,
+        MapperService mapperService
+    ) {
+        List<StarTreeField> starTreeFields = new ArrayList<>();
+        for (CompositeMappedFieldType compositeMappedFieldType : mapperService.getCompositeFieldTypes()) {
+            if (compositeMappedFieldType instanceof StarTreeMapper.StarTreeFieldType) {
+                StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) compositeMappedFieldType;
+                starTreeFields.add(
+                    new StarTreeField(
+                        starTreeFieldType.name(),
+                        starTreeFieldType.getDimensions(),
+                        starTreeFieldType.getMetrics(),
+                        starTreeFieldType.getStarTreeConfig()
+                    )
+                );
+            }
+        }
+
+        this.starTreeFields = starTreeFields;
+        this.fieldProducerMap = fieldProducerMap;
+        this.state = segmentWriteState;
+        this.mapperService = mapperService;
+    }
+
+    /**
+     * Builds the star-trees.
+     */
+    public void build() throws IOException {
+        if (starTreeFields.isEmpty()) {
+            logger.debug("no star-tree fields found, returning from star-tree builder");
+            return;
+        }
+        long startTime = System.currentTimeMillis();
+        int numStarTrees = starTreeFields.size();
+        logger.debug("Starting building {} star-trees with star-tree fields", numStarTrees);
+
+        // Build all star-trees
+        for (StarTreeField starTreeField : starTreeFields) {
+            try (StarTreeBuilder starTreeBuilder = getStarTreeBuilder(starTreeField, fieldProducerMap, state, mapperService)) {
+                starTreeBuilder.build();
+            }
+        }
+        logger.debug("Took {} ms to building {} star-trees with star-tree fields", System.currentTimeMillis() - startTime, numStarTrees);
+    }
+
+    @Override
+    public void close() throws IOException {
+
+    }
+
+    StarTreeBuilder getStarTreeBuilder(
+        StarTreeField starTreeField,
+        Map<String, DocValuesProducer> fieldProducerMap,
+        SegmentWriteState state,
+        MapperService mapperService
+    ) throws IOException {
+        switch (starTreeField.getStarTreeConfig().getBuildMode()) {
+            case ON_HEAP:
+                return new OnHeapStarTreeBuilder(starTreeField, fieldProducerMap, state, mapperService);
+            default:
+                throw new IllegalArgumentException(
+                    String.format(
+                        Locale.ROOT,
+                        "No star tree implementation is available for [%s] build mode",
+                        starTreeField.getStarTreeConfig().getBuildMode()
+                    )
+                );
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/package-info.java
new file mode 100644
index 0000000000000..9c97b076371a3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/package-info.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Builders for Composite Index Star Tree
+ *
+ * @opensearch.experimental
+ */
+package org.opensearch.index.compositeindex.datacube.startree.builder;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/package-info.java
index 4f4e670478e2f..6d6cb420f4a9e 100644
--- a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/package-info.java
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/package-info.java
@@ -7,5 +7,7 @@
  */
 /**
  * Core classes for handling star tree index.
+ *
+ * @opensearch.experimental
  */
 package org.opensearch.index.compositeindex.datacube.startree;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/SequentialDocValuesIterator.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/SequentialDocValuesIterator.java
new file mode 100644
index 0000000000000..cf5f3e94c1ca6
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/SequentialDocValuesIterator.java
@@ -0,0 +1,137 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.utils;
+
+import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.search.DocIdSetIterator;
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.io.IOException;
+
+/**
+ * Coordinates the reading of documents across multiple DocIdSetIterators.
+ * It encapsulates a single DocIdSetIterator and maintains the latest document ID and its associated value.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class SequentialDocValuesIterator {
+
+    /**
+     * The doc id set iterator associated for each field.
+     */
+    private final DocIdSetIterator docIdSetIterator;
+
+    /**
+     * The value associated with the latest document.
+     */
+    private Long docValue;
+
+    /**
+     * The id of the latest document.
+     */
+    private int docId;
+
+    /**
+     * Constructs a new SequentialDocValuesIterator instance with the given DocIdSetIterator.
+     *
+     * @param docIdSetIterator the DocIdSetIterator to be associated with this instance
+     */
+    public SequentialDocValuesIterator(DocIdSetIterator docIdSetIterator) {
+        this.docIdSetIterator = docIdSetIterator;
+    }
+
+    /**
+     * Constructs a new SequentialDocValuesIterator instance with the given SortedNumericDocValues.
+     *
+     */
+    public SequentialDocValuesIterator() {
+        this.docIdSetIterator = new SortedNumericDocValues() {
+            @Override
+            public long nextValue() throws IOException {
+                return 0;
+            }
+
+            @Override
+            public int docValueCount() {
+                return 0;
+            }
+
+            @Override
+            public boolean advanceExact(int i) throws IOException {
+                return false;
+            }
+
+            @Override
+            public int docID() {
+                return 0;
+            }
+
+            @Override
+            public int nextDoc() throws IOException {
+                return 0;
+            }
+
+            @Override
+            public int advance(int i) throws IOException {
+                return 0;
+            }
+
+            @Override
+            public long cost() {
+                return 0;
+            }
+        };
+    }
+
+    /**
+     * Returns the value associated with the latest document.
+     *
+     * @return the value associated with the latest document
+     */
+    public Long getDocValue() {
+        return docValue;
+    }
+
+    /**
+     * Sets the value associated with the latest document.
+     *
+     * @param docValue the value to be associated with the latest document
+     */
+    public void setDocValue(Long docValue) {
+        this.docValue = docValue;
+    }
+
+    /**
+     * Returns the id of the latest document.
+     *
+     * @return the id of the latest document
+     */
+    public int getDocId() {
+        return docId;
+    }
+
+    /**
+     * Sets the id of the latest document.
+     *
+     * @param docId the ID of the latest document
+     */
+    public void setDocId(int docId) {
+        this.docId = docId;
+    }
+
+    /**
+     * Returns the DocIdSetIterator associated with this instance.
+     *
+     * @return the DocIdSetIterator associated with this instance
+     */
+    public DocIdSetIterator getDocIdSetIterator() {
+        return docIdSetIterator;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/TreeNode.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/TreeNode.java
new file mode 100644
index 0000000000000..5cf737c61ab2d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/TreeNode.java
@@ -0,0 +1,65 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.utils;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.util.Map;
+
+/**
+ * /**
+ * Represents a node in a tree data structure, specifically designed for a star-tree implementation.
+ * A star-tree node will represent both star and non-star nodes.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class TreeNode {
+
+    public static final int ALL = -1;
+
+    /**
+     * The dimension id for the dimension (field) associated with this star-tree node.
+     */
+    public int dimensionId = ALL;
+
+    /**
+     * The starting document id (inclusive) associated with this star-tree node.
+     */
+    public int startDocId = ALL;
+
+    /**
+     * The ending document id (exclusive) associated with this star-tree node.
+     */
+    public int endDocId = ALL;
+
+    /**
+     * The aggregated document id associated with this star-tree node.
+     */
+    public int aggregatedDocId = ALL;
+
+    /**
+     * The child dimension identifier associated with this star-tree node.
+     */
+    public int childDimensionId = ALL;
+
+    /**
+     * The value of the dimension associated with this star-tree node.
+     */
+    public long dimensionValue = ALL;
+
+    /**
+     * A flag indicating whether this node is a star node (a node that represents an aggregation of all dimensions).
+     */
+    public boolean isStarNode = false;
+
+    /**
+     * A map containing the child nodes of this star-tree node, keyed by their dimension id.
+     */
+    public Map<Long, TreeNode> children;
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/package-info.java
new file mode 100644
index 0000000000000..c7e8b04d42178
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/package-info.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Utility to support Composite Index Star Tree
+ *
+ * @opensearch.experimental
+ */
+package org.opensearch.index.compositeindex.datacube.startree.utils;
diff --git a/server/src/main/java/org/opensearch/index/mapper/ConstantKeywordFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/ConstantKeywordFieldMapper.java
index f4730c70362d1..2edd817f61f61 100644
--- a/server/src/main/java/org/opensearch/index/mapper/ConstantKeywordFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/ConstantKeywordFieldMapper.java
@@ -68,11 +68,11 @@ private static ConstantKeywordFieldMapper toType(FieldMapper in) {
      */
     public static class Builder extends ParametrizedFieldMapper.Builder {
 
-        private final Parameter<String> value;
+        private final Parameter<String> value = Parameter.stringParam(valuePropertyName, false, m -> toType(m).value, null);
 
         public Builder(String name, String value) {
             super(name);
-            this.value = Parameter.stringParam(valuePropertyName, false, m -> toType(m).value, value);
+            this.value.setValue(value);
         }
 
         @Override
diff --git a/server/src/main/java/org/opensearch/index/query/ExistsQueryBuilder.java b/server/src/main/java/org/opensearch/index/query/ExistsQueryBuilder.java
index 3011a48fbb296..6ae40fe1b1e64 100644
--- a/server/src/main/java/org/opensearch/index/query/ExistsQueryBuilder.java
+++ b/server/src/main/java/org/opensearch/index/query/ExistsQueryBuilder.java
@@ -230,20 +230,16 @@ private static Collection<String> getMappedField(QueryShardContext context, Stri
         if (context.getObjectMapper(fieldPattern) != null) {
             // the _field_names field also indexes objects, so we don't have to
             // do any more work to support exists queries on whole objects
-            fields = Collections.singleton(fieldPattern);
+            return Collections.singleton(fieldPattern);
         } else {
             fields = context.simpleMatchToIndexNames(fieldPattern);
         }
 
         if (fields.size() == 1) {
             String field = fields.iterator().next();
-            MappedFieldType fieldType = context.getMapperService().fieldType(field);
+            MappedFieldType fieldType = context.fieldMapper(field);
             if (fieldType == null) {
-                // The field does not exist as a leaf but could be an object so
-                // check for an object mapper
-                if (context.getObjectMapper(field) == null) {
-                    return Collections.emptySet();
-                }
+                return Collections.emptySet();
             }
         }
 
diff --git a/server/src/main/java/org/opensearch/index/remote/RemoteStoreUtils.java b/server/src/main/java/org/opensearch/index/remote/RemoteStoreUtils.java
index 9a9de6c819424..a5e0c10f72301 100644
--- a/server/src/main/java/org/opensearch/index/remote/RemoteStoreUtils.java
+++ b/server/src/main/java/org/opensearch/index/remote/RemoteStoreUtils.java
@@ -11,17 +11,23 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.opensearch.Version;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.RoutingTable;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.node.remotestore.RemoteStoreNodeAttribute;
+import org.opensearch.node.remotestore.RemoteStoreNodeService;
 
 import java.nio.ByteBuffer;
 import java.util.Arrays;
 import java.util.Base64;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
@@ -29,7 +35,9 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
+import static org.opensearch.index.remote.RemoteMigrationIndexMetadataUpdater.indexHasRemoteStoreSettings;
 import static org.opensearch.indices.RemoteStoreSettings.CLUSTER_REMOTE_STORE_PATH_HASH_ALGORITHM_SETTING;
 import static org.opensearch.indices.RemoteStoreSettings.CLUSTER_REMOTE_STORE_PATH_TYPE_SETTING;
 import static org.opensearch.indices.RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_METADATA;
@@ -214,13 +222,13 @@ public static Map<String, String> determineRemoteStoreCustomMetadataDuringMigrat
         // does not support custom metadata.
         // https://github.com/opensearch-project/OpenSearch/issues/13745
         boolean blobStoreMetadataEnabled = false;
-        boolean translogMetadata = Version.CURRENT.compareTo(minNodeVersion) <= 0
+        boolean translogMetadata = Version.V_2_15_0.compareTo(minNodeVersion) <= 0
             && CLUSTER_REMOTE_STORE_TRANSLOG_METADATA.get(clusterSettings)
             && blobStoreMetadataEnabled;
 
         remoteCustomData.put(IndexMetadata.TRANSLOG_METADATA_KEY, Boolean.toString(translogMetadata));
 
-        RemoteStoreEnums.PathType pathType = Version.CURRENT.compareTo(minNodeVersion) <= 0
+        RemoteStoreEnums.PathType pathType = Version.V_2_15_0.compareTo(minNodeVersion) <= 0
             ? CLUSTER_REMOTE_STORE_PATH_TYPE_SETTING.get(clusterSettings)
             : RemoteStoreEnums.PathType.FIXED;
         RemoteStoreEnums.PathHashAlgorithm pathHashAlgorithm = pathType == RemoteStoreEnums.PathType.FIXED
@@ -250,4 +258,119 @@ public static Map<String, String> getRemoteStoreRepoName(DiscoveryNodes discover
             .findFirst();
         return remoteNode.map(RemoteStoreNodeAttribute::getDataRepoNames).orElseGet(HashMap::new);
     }
+
+    /**
+     * Invoked after a cluster settings update.
+     * Checks if the applied cluster settings has switched the cluster to STRICT mode.
+     * If so, checks and applies appropriate index settings depending on the current set
+     * of node types in the cluster
+     * This has been intentionally done after the cluster settings update
+     * flow. That way we are not interfering with the usual settings update
+     * and the cluster state mutation that comes along with it
+     *
+     * @param isCompatibilityModeChanging flag passed from cluster settings update call to denote if a compatibility mode change has been done
+     * @param request request payload passed from cluster settings update
+     * @param currentState cluster state generated after changing cluster settings were applied
+     * @param logger Logger reference
+     * @return Mutated cluster state with remote store index settings applied, no-op if the cluster is not switching to `STRICT` compatibility mode
+     */
+    public static ClusterState checkAndFinalizeRemoteStoreMigration(
+        boolean isCompatibilityModeChanging,
+        ClusterUpdateSettingsRequest request,
+        ClusterState currentState,
+        Logger logger
+    ) {
+        if (isCompatibilityModeChanging && isSwitchToStrictCompatibilityMode(request)) {
+            return finalizeMigration(currentState, logger);
+        }
+        return currentState;
+    }
+
+    /**
+     * Finalizes the docrep to remote-store migration process by applying remote store based index settings
+     * on indices that are missing them. No-Op if all indices already have the settings applied through
+     * IndexMetadataUpdater
+     *
+     * @param incomingState mutated cluster state after cluster settings were applied
+     * @return new cluster state with index settings updated
+     */
+    public static ClusterState finalizeMigration(ClusterState incomingState, Logger logger) {
+        Map<String, DiscoveryNode> discoveryNodeMap = incomingState.nodes().getNodes();
+        if (discoveryNodeMap.isEmpty() == false) {
+            // At this point, we have already validated that all nodes in the cluster are of uniform type.
+            // Either all of them are remote store enabled, or all of them are docrep enabled
+            boolean remoteStoreEnabledNodePresent = discoveryNodeMap.values().stream().findFirst().get().isRemoteStoreNode();
+            if (remoteStoreEnabledNodePresent == true) {
+                List<IndexMetadata> indicesWithoutRemoteStoreSettings = getIndicesWithoutRemoteStoreSettings(incomingState, logger);
+                if (indicesWithoutRemoteStoreSettings.isEmpty() == true) {
+                    logger.info("All indices in the cluster has remote store based index settings");
+                } else {
+                    Metadata mutatedMetadata = applyRemoteStoreSettings(incomingState, indicesWithoutRemoteStoreSettings, logger);
+                    return ClusterState.builder(incomingState).metadata(mutatedMetadata).build();
+                }
+            } else {
+                logger.debug("All nodes in the cluster are not remote nodes. Skipping.");
+            }
+        }
+        return incomingState;
+    }
+
+    /**
+     * Filters out indices which does not have remote store based
+     * index settings applied even after all shard copies have
+     * migrated to remote store enabled nodes
+     */
+    private static List<IndexMetadata> getIndicesWithoutRemoteStoreSettings(ClusterState clusterState, Logger logger) {
+        Collection<IndexMetadata> allIndicesMetadata = clusterState.metadata().indices().values();
+        if (allIndicesMetadata.isEmpty() == false) {
+            List<IndexMetadata> indicesWithoutRemoteSettings = allIndicesMetadata.stream()
+                .filter(idxMd -> indexHasRemoteStoreSettings(idxMd.getSettings()) == false)
+                .collect(Collectors.toList());
+            logger.debug(
+                "Attempting to switch to strict mode. Count of indices without remote store settings {}",
+                indicesWithoutRemoteSettings.size()
+            );
+            return indicesWithoutRemoteSettings;
+        }
+        return Collections.emptyList();
+    }
+
+    /**
+     * Applies remote store index settings through {@link RemoteMigrationIndexMetadataUpdater}
+     */
+    private static Metadata applyRemoteStoreSettings(
+        ClusterState clusterState,
+        List<IndexMetadata> indicesWithoutRemoteStoreSettings,
+        Logger logger
+    ) {
+        Metadata.Builder metadataBuilder = Metadata.builder(clusterState.getMetadata());
+        RoutingTable currentRoutingTable = clusterState.getRoutingTable();
+        DiscoveryNodes currentDiscoveryNodes = clusterState.getNodes();
+        Settings currentClusterSettings = clusterState.metadata().settings();
+        for (IndexMetadata indexMetadata : indicesWithoutRemoteStoreSettings) {
+            IndexMetadata.Builder indexMetadataBuilder = IndexMetadata.builder(indexMetadata);
+            RemoteMigrationIndexMetadataUpdater indexMetadataUpdater = new RemoteMigrationIndexMetadataUpdater(
+                currentDiscoveryNodes,
+                currentRoutingTable,
+                indexMetadata,
+                currentClusterSettings,
+                logger
+            );
+            indexMetadataUpdater.maybeAddRemoteIndexSettings(indexMetadataBuilder, indexMetadata.getIndex().getName());
+            metadataBuilder.put(indexMetadataBuilder);
+        }
+        return metadataBuilder.build();
+    }
+
+    /**
+     * Checks if the incoming cluster settings payload is attempting to switch
+     * the cluster to `STRICT` compatibility mode
+     * Visible only for tests
+     */
+    public static boolean isSwitchToStrictCompatibilityMode(ClusterUpdateSettingsRequest request) {
+        Settings incomingSettings = Settings.builder().put(request.persistentSettings()).put(request.transientSettings()).build();
+        return RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING.get(
+            incomingSettings
+        ) == RemoteStoreNodeService.CompatibilityMode.STRICT;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/index/search/QueryParserHelper.java b/server/src/main/java/org/opensearch/index/search/QueryParserHelper.java
index 06f450f090e63..603e81f6bf113 100644
--- a/server/src/main/java/org/opensearch/index/search/QueryParserHelper.java
+++ b/server/src/main/java/org/opensearch/index/search/QueryParserHelper.java
@@ -143,7 +143,7 @@ static Map<String, Float> resolveMappingField(
                 fieldName = fieldName + fieldSuffix;
             }
 
-            MappedFieldType fieldType = context.getMapperService().fieldType(fieldName);
+            MappedFieldType fieldType = context.fieldMapper(fieldName);
             if (fieldType == null) {
                 fieldType = context.resolveDerivedFieldType(fieldName);
             }
diff --git a/server/src/main/java/org/opensearch/index/store/remote/utils/TransferManager.java b/server/src/main/java/org/opensearch/index/store/remote/utils/TransferManager.java
index df26f2f0925f6..f07c4832d982c 100644
--- a/server/src/main/java/org/opensearch/index/store/remote/utils/TransferManager.java
+++ b/server/src/main/java/org/opensearch/index/store/remote/utils/TransferManager.java
@@ -64,16 +64,22 @@ public IndexInput fetchBlob(BlobFetchRequest blobFetchRequest) throws IOExceptio
         final Path key = blobFetchRequest.getFilePath();
         logger.trace("fetchBlob called for {}", key.toString());
 
-        final CachedIndexInput cacheEntry = fileCache.compute(key, (path, cachedIndexInput) -> {
-            if (cachedIndexInput == null || cachedIndexInput.isClosed()) {
-                logger.trace("Transfer Manager - IndexInput closed or not in cache");
-                // Doesn't exist or is closed, either way create a new one
-                return new DelayedCreationCachedIndexInput(fileCache, streamReader, blobFetchRequest);
-            } else {
-                logger.trace("Transfer Manager - Already in cache");
-                // already in the cache and ready to be used (open)
-                return cachedIndexInput;
-            }
+        // We need to do a privileged action here in order to fetch from remote
+        // and write/evict from local file cache in case this is invoked as a side
+        // effect of a plugin (such as a scripted search) that doesn't have the
+        // necessary permissions.
+        final CachedIndexInput cacheEntry = AccessController.doPrivileged((PrivilegedAction<CachedIndexInput>) () -> {
+            return fileCache.compute(key, (path, cachedIndexInput) -> {
+                if (cachedIndexInput == null || cachedIndexInput.isClosed()) {
+                    logger.trace("Transfer Manager - IndexInput closed or not in cache");
+                    // Doesn't exist or is closed, either way create a new one
+                    return new DelayedCreationCachedIndexInput(fileCache, streamReader, blobFetchRequest);
+                } else {
+                    logger.trace("Transfer Manager - Already in cache");
+                    // already in the cache and ready to be used (open)
+                    return cachedIndexInput;
+                }
+            });
         });
 
         // Cache entry was either retrieved from the cache or newly added, either
@@ -88,37 +94,31 @@ public IndexInput fetchBlob(BlobFetchRequest blobFetchRequest) throws IOExceptio
 
     @SuppressWarnings("removal")
     private static FileCachedIndexInput createIndexInput(FileCache fileCache, StreamReader streamReader, BlobFetchRequest request) {
-        // We need to do a privileged action here in order to fetch from remote
-        // and write to the local file cache in case this is invoked as a side
-        // effect of a plugin (such as a scripted search) that doesn't have the
-        // necessary permissions.
-        return AccessController.doPrivileged((PrivilegedAction<FileCachedIndexInput>) () -> {
-            try {
-                if (Files.exists(request.getFilePath()) == false) {
-                    logger.trace("Fetching from Remote in createIndexInput of Transfer Manager");
-                    try (
-                        OutputStream fileOutputStream = Files.newOutputStream(request.getFilePath());
-                        OutputStream localFileOutputStream = new BufferedOutputStream(fileOutputStream)
-                    ) {
-                        for (BlobFetchRequest.BlobPart blobPart : request.blobParts()) {
-                            try (
-                                InputStream snapshotFileInputStream = streamReader.read(
-                                    blobPart.getBlobName(),
-                                    blobPart.getPosition(),
-                                    blobPart.getLength()
-                                );
-                            ) {
-                                snapshotFileInputStream.transferTo(localFileOutputStream);
-                            }
+        try {
+            if (Files.exists(request.getFilePath()) == false) {
+                logger.trace("Fetching from Remote in createIndexInput of Transfer Manager");
+                try (
+                    OutputStream fileOutputStream = Files.newOutputStream(request.getFilePath());
+                    OutputStream localFileOutputStream = new BufferedOutputStream(fileOutputStream)
+                ) {
+                    for (BlobFetchRequest.BlobPart blobPart : request.blobParts()) {
+                        try (
+                            InputStream snapshotFileInputStream = streamReader.read(
+                                blobPart.getBlobName(),
+                                blobPart.getPosition(),
+                                blobPart.getLength()
+                            );
+                        ) {
+                            snapshotFileInputStream.transferTo(localFileOutputStream);
                         }
                     }
                 }
-                final IndexInput luceneIndexInput = request.getDirectory().openInput(request.getFileName(), IOContext.READ);
-                return new FileCachedIndexInput(fileCache, request.getFilePath(), luceneIndexInput);
-            } catch (IOException e) {
-                throw new UncheckedIOException(e);
             }
-        });
+            final IndexInput luceneIndexInput = request.getDirectory().openInput(request.getFileName(), IOContext.READ);
+            return new FileCachedIndexInput(fileCache, request.getFilePath(), luceneIndexInput);
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/indices/tiering/TieringRequestValidator.java b/server/src/main/java/org/opensearch/indices/tiering/TieringRequestValidator.java
new file mode 100644
index 0000000000000..2de50f4d4295d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/tiering/TieringRequestValidator.java
@@ -0,0 +1,277 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.tiering;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.action.admin.indices.tiering.TieringValidationResult;
+import org.opensearch.cluster.ClusterInfo;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.DiskUsage;
+import org.opensearch.cluster.health.ClusterHealthStatus;
+import org.opensearch.cluster.health.ClusterIndexHealth;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.allocation.DiskThresholdSettings;
+import org.opensearch.core.index.Index;
+import org.opensearch.index.IndexModule;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.opensearch.index.IndexModule.INDEX_TIERING_STATE;
+
+/**
+ * Validator class to validate the tiering requests of the index
+ * @opensearch.experimental
+ */
+public class TieringRequestValidator {
+
+    private static final Logger logger = LogManager.getLogger(TieringRequestValidator.class);
+
+    /**
+     * Validates the tiering request for indices going from hot to warm tier
+     *
+     * @param currentState current cluster state
+     * @param concreteIndices set of indices to be validated
+     * @param clusterInfo the current nodes usage info for the cluster
+     * @param diskThresholdSettings the disk threshold settings of the cluster
+     * @return result of the validation
+     */
+    public static TieringValidationResult validateHotToWarm(
+        final ClusterState currentState,
+        final Set<Index> concreteIndices,
+        final ClusterInfo clusterInfo,
+        final DiskThresholdSettings diskThresholdSettings
+    ) {
+        final String indexNames = concreteIndices.stream().map(Index::getName).collect(Collectors.joining(", "));
+        validateSearchNodes(currentState, indexNames);
+        validateDiskThresholdWaterMarkNotBreached(currentState, clusterInfo, diskThresholdSettings, indexNames);
+
+        final TieringValidationResult tieringValidationResult = new TieringValidationResult(concreteIndices);
+
+        for (Index index : concreteIndices) {
+            if (!validateHotIndex(currentState, index)) {
+                tieringValidationResult.addToRejected(index, "index is not in the HOT tier");
+                continue;
+            }
+            if (!validateRemoteStoreIndex(currentState, index)) {
+                tieringValidationResult.addToRejected(index, "index is not backed up by the remote store");
+                continue;
+            }
+            if (!validateOpenIndex(currentState, index)) {
+                tieringValidationResult.addToRejected(index, "index is closed");
+                continue;
+            }
+            if (!validateIndexHealth(currentState, index)) {
+                tieringValidationResult.addToRejected(index, "index is red");
+                continue;
+            }
+        }
+
+        validateEligibleNodesCapacity(clusterInfo, currentState, tieringValidationResult);
+        logger.info(
+            "Successfully accepted indices for tiering are [{}], rejected indices are [{}]",
+            tieringValidationResult.getAcceptedIndices(),
+            tieringValidationResult.getRejectedIndices()
+        );
+
+        return tieringValidationResult;
+    }
+
+    /**
+     * Validates that there are eligible nodes with the search role in the current cluster state.
+     * (only for the dedicated case - to be removed later)
+     *
+     * @param currentState the current cluster state
+     * @param indexNames the names of the indices being validated
+     * @throws IllegalArgumentException if there are no eligible search nodes in the cluster
+     */
+    static void validateSearchNodes(final ClusterState currentState, final String indexNames) {
+        if (getEligibleNodes(currentState).isEmpty()) {
+            final String errorMsg = "Rejecting tiering request for indices ["
+                + indexNames
+                + "] because there are no nodes found with the search role";
+            logger.warn(errorMsg);
+            throw new IllegalArgumentException(errorMsg);
+        }
+    }
+
+    /**
+     * Validates that the specified index has the remote store setting enabled.
+     *
+     * @param state the current cluster state
+     * @param index the index to be validated
+     * @return true if the remote store setting is enabled for the index, false otherwise
+     */
+    static boolean validateRemoteStoreIndex(final ClusterState state, final Index index) {
+        return IndexMetadata.INDEX_REMOTE_STORE_ENABLED_SETTING.get(state.metadata().getIndexSafe(index).getSettings());
+    }
+
+    /**
+     * Validates that the specified index is in the "hot" tiering state.
+     *
+     * @param state the current cluster state
+     * @param index the index to be validated
+     * @return true if the index is in the "hot" tiering state, false otherwise
+     */
+    static boolean validateHotIndex(final ClusterState state, final Index index) {
+        return IndexModule.TieringState.HOT.name().equals(INDEX_TIERING_STATE.get(state.metadata().getIndexSafe(index).getSettings()));
+    }
+
+    /**
+     * Validates the health of the specified index in the current cluster state.
+     *
+     * @param currentState the current cluster state
+     * @param index the index to be validated
+     * @return true if the index health is not in the "red" state, false otherwise
+     */
+    static boolean validateIndexHealth(final ClusterState currentState, final Index index) {
+        final IndexRoutingTable indexRoutingTable = currentState.routingTable().index(index);
+        final IndexMetadata indexMetadata = currentState.metadata().index(index);
+        final ClusterIndexHealth indexHealth = new ClusterIndexHealth(indexMetadata, indexRoutingTable);
+        return !ClusterHealthStatus.RED.equals(indexHealth.getStatus());
+    }
+
+    /**
+     * Validates that the specified index is in the open state in the current cluster state.
+     *
+     * @param currentState the current cluster state
+     * @param index the index to be validated
+     * @return true if the index is in the open state, false otherwise
+     */
+    static boolean validateOpenIndex(final ClusterState currentState, final Index index) {
+        return currentState.metadata().index(index).getState() == IndexMetadata.State.OPEN;
+    }
+
+    /**
+     * Validates that the disk threshold low watermark is not breached on all the eligible nodes in the cluster.
+     *
+     * @param currentState the current cluster state
+     * @param clusterInfo the current nodes usage info for the cluster
+     * @param diskThresholdSettings the disk threshold settings of the cluster
+     * @param indexNames the names of the indices being validated
+     * @throws IllegalArgumentException if the disk threshold low watermark is breached on all eligible nodes
+     */
+    static void validateDiskThresholdWaterMarkNotBreached(
+        final ClusterState currentState,
+        final ClusterInfo clusterInfo,
+        final DiskThresholdSettings diskThresholdSettings,
+        final String indexNames
+    ) {
+        final Map<String, DiskUsage> usages = clusterInfo.getNodeLeastAvailableDiskUsages();
+        if (usages == null) {
+            logger.trace("skipping monitor as no disk usage information is available");
+            return;
+        }
+        final Set<String> nodeIds = getEligibleNodes(currentState).stream().map(DiscoveryNode::getId).collect(Collectors.toSet());
+        for (String node : nodeIds) {
+            final DiskUsage nodeUsage = usages.get(node);
+            if (nodeUsage != null && nodeUsage.getFreeBytes() > diskThresholdSettings.getFreeBytesThresholdLow().getBytes()) {
+                return;
+            }
+        }
+        throw new IllegalArgumentException(
+            "Disk threshold low watermark is breached on all the search nodes, rejecting tiering request for indices: " + indexNames
+        );
+    }
+
+    /**
+     * Validates the capacity of eligible nodes in the cluster to accommodate the specified indices
+     * and adds the rejected indices to tieringValidationResult
+     *
+     * @param clusterInfo the current nodes usage info for the cluster
+     * @param currentState the current cluster state
+     * @param tieringValidationResult contains the indices to validate
+     */
+    static void validateEligibleNodesCapacity(
+        final ClusterInfo clusterInfo,
+        final ClusterState currentState,
+        final TieringValidationResult tieringValidationResult
+    ) {
+
+        final Set<String> eligibleNodeIds = getEligibleNodes(currentState).stream().map(DiscoveryNode::getId).collect(Collectors.toSet());
+        long totalAvailableBytesInWarmTier = getTotalAvailableBytesInWarmTier(
+            clusterInfo.getNodeLeastAvailableDiskUsages(),
+            eligibleNodeIds
+        );
+
+        Map<Index, Long> indexSizes = new HashMap<>();
+        for (Index index : tieringValidationResult.getAcceptedIndices()) {
+            indexSizes.put(index, getIndexPrimaryStoreSize(currentState, clusterInfo, index.getName()));
+        }
+
+        if (indexSizes.values().stream().mapToLong(Long::longValue).sum() < totalAvailableBytesInWarmTier) {
+            return;
+        }
+        HashMap<Index, Long> sortedIndexSizes = indexSizes.entrySet()
+            .stream()
+            .sorted(Map.Entry.comparingByValue())
+            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, HashMap::new));
+
+        long requestIndexBytes = 0L;
+        for (Index index : sortedIndexSizes.keySet()) {
+            requestIndexBytes += sortedIndexSizes.get(index);
+            if (requestIndexBytes >= totalAvailableBytesInWarmTier) {
+                tieringValidationResult.addToRejected(index, "insufficient node capacity");
+            }
+        }
+    }
+
+    /**
+     * Calculates the total size of the specified index in the cluster.
+     * Note: This function only accounts for the primary shard size.
+     *
+     * @param clusterState the current state of the cluster
+     * @param clusterInfo  the current nodes usage info for the cluster
+     * @param index        the name of the index for which the total size is to be calculated
+     * @return the total size of the specified index in the cluster
+     */
+    static long getIndexPrimaryStoreSize(ClusterState clusterState, ClusterInfo clusterInfo, String index) {
+        long totalIndexSize = 0;
+        List<ShardRouting> shardRoutings = clusterState.routingTable().allShards(index);
+        for (ShardRouting shardRouting : shardRoutings) {
+            if (shardRouting.primary()) {
+                totalIndexSize += clusterInfo.getShardSize(shardRouting, 0);
+            }
+        }
+        return totalIndexSize;
+    }
+
+    /**
+     * Calculates the total available bytes in the warm tier of the cluster.
+     *
+     * @param usages the current disk usage of the cluster
+     * @param nodeIds the set of warm nodes ids in the cluster
+     * @return the total available bytes in the warm tier
+     */
+    static long getTotalAvailableBytesInWarmTier(final Map<String, DiskUsage> usages, final Set<String> nodeIds) {
+        long totalAvailableBytes = 0;
+        for (String node : nodeIds) {
+            totalAvailableBytes += usages.get(node).getFreeBytes();
+        }
+        return totalAvailableBytes;
+    }
+
+    /**
+     * Retrieves the set of eligible(search) nodes from the current cluster state.
+     *
+     * @param currentState the current cluster state
+     * @return the set of eligible nodes
+     */
+    static Set<DiscoveryNode> getEligibleNodes(final ClusterState currentState) {
+        final Map<String, DiscoveryNode> nodes = currentState.getNodes().getDataNodes();
+        return nodes.values().stream().filter(DiscoveryNode::isSearchNode).collect(Collectors.toSet());
+    }
+}
diff --git a/server/src/main/java/org/opensearch/indices/tiering/package-info.java b/server/src/main/java/org/opensearch/indices/tiering/package-info.java
new file mode 100644
index 0000000000000..552f87382ea15
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/tiering/package-info.java
@@ -0,0 +1,36 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/**
+ * Validator layer checks that OpenSearch can perform to tier the indices
+ */
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.indices.tiering;
diff --git a/server/src/main/java/org/opensearch/ingest/IngestService.java b/server/src/main/java/org/opensearch/ingest/IngestService.java
index 2281ccd4c0382..17eb23422e68b 100644
--- a/server/src/main/java/org/opensearch/ingest/IngestService.java
+++ b/server/src/main/java/org/opensearch/ingest/IngestService.java
@@ -525,61 +525,7 @@ public void onFailure(Exception e) {
 
             @Override
             protected void doRun() {
-                int batchSize = originalBulkRequest.batchSize();
-                if (shouldExecuteBulkRequestInBatch(originalBulkRequest.requests().size(), batchSize)) {
-                    runBulkRequestInBatch(numberOfActionRequests, actionRequests, onFailure, onCompletion, onDropped, originalBulkRequest);
-                    return;
-                }
-
-                final Thread originalThread = Thread.currentThread();
-                final AtomicInteger counter = new AtomicInteger(numberOfActionRequests);
-                int i = 0;
-                for (DocWriteRequest<?> actionRequest : actionRequests) {
-                    IndexRequest indexRequest = TransportBulkAction.getIndexWriteRequest(actionRequest);
-                    if (indexRequest == null) {
-                        if (counter.decrementAndGet() == 0) {
-                            onCompletion.accept(originalThread, null);
-                        }
-                        assert counter.get() >= 0;
-                        i++;
-                        continue;
-                    }
-                    final String pipelineId = indexRequest.getPipeline();
-                    indexRequest.setPipeline(NOOP_PIPELINE_NAME);
-                    final String finalPipelineId = indexRequest.getFinalPipeline();
-                    indexRequest.setFinalPipeline(NOOP_PIPELINE_NAME);
-                    boolean hasFinalPipeline = true;
-                    final List<String> pipelines;
-                    if (IngestService.NOOP_PIPELINE_NAME.equals(pipelineId) == false
-                        && IngestService.NOOP_PIPELINE_NAME.equals(finalPipelineId) == false) {
-                        pipelines = Arrays.asList(pipelineId, finalPipelineId);
-                    } else if (IngestService.NOOP_PIPELINE_NAME.equals(pipelineId) == false) {
-                        pipelines = Collections.singletonList(pipelineId);
-                        hasFinalPipeline = false;
-                    } else if (IngestService.NOOP_PIPELINE_NAME.equals(finalPipelineId) == false) {
-                        pipelines = Collections.singletonList(finalPipelineId);
-                    } else {
-                        if (counter.decrementAndGet() == 0) {
-                            onCompletion.accept(originalThread, null);
-                        }
-                        assert counter.get() >= 0;
-                        i++;
-                        continue;
-                    }
-
-                    executePipelines(
-                        i,
-                        pipelines.iterator(),
-                        hasFinalPipeline,
-                        indexRequest,
-                        onDropped,
-                        onFailure,
-                        counter,
-                        onCompletion,
-                        originalThread
-                    );
-                    i++;
-                }
+                runBulkRequestInBatch(numberOfActionRequests, actionRequests, onFailure, onCompletion, onDropped, originalBulkRequest);
             }
         });
     }
@@ -635,7 +581,7 @@ private void runBulkRequestInBatch(
             i++;
         }
 
-        int batchSize = originalBulkRequest.batchSize();
+        int batchSize = Math.min(numberOfActionRequests, originalBulkRequest.batchSize());
         List<List<IndexRequestWrapper>> batches = prepareBatches(batchSize, indexRequestWrappers);
         logger.debug("batchSize: {}, batches: {}", batchSize, batches.size());
 
@@ -654,10 +600,6 @@ private void runBulkRequestInBatch(
         }
     }
 
-    private boolean shouldExecuteBulkRequestInBatch(int documentSize, int batchSize) {
-        return documentSize > 1 && batchSize > 1;
-    }
-
     /**
      * IndexRequests are grouped by unique (index + pipeline_ids) before batching.
      * Only IndexRequests in the same group could be batched. It's to ensure batched documents always
@@ -685,7 +627,7 @@ static List<List<IndexRequestWrapper>> prepareBatches(int batchSize, List<IndexR
         }
         List<List<IndexRequestWrapper>> batchedIndexRequests = new ArrayList<>();
         for (Map.Entry<Integer, List<IndexRequestWrapper>> indexRequestsPerKey : indexRequestsPerIndexAndPipelines.entrySet()) {
-            for (int i = 0; i < indexRequestsPerKey.getValue().size(); i += batchSize) {
+            for (int i = 0; i < indexRequestsPerKey.getValue().size(); i += Math.min(indexRequestsPerKey.getValue().size(), batchSize)) {
                 batchedIndexRequests.add(
                     new ArrayList<>(
                         indexRequestsPerKey.getValue().subList(i, i + Math.min(batchSize, indexRequestsPerKey.getValue().size() - i))
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index a8873aceff3b0..951353a1cf75c 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -52,6 +52,7 @@
 import org.opensearch.action.search.SearchRequestOperationsListener;
 import org.opensearch.action.search.SearchRequestSlowLog;
 import org.opensearch.action.search.SearchRequestStats;
+import org.opensearch.action.search.SearchTaskRequestOperationsListener;
 import org.opensearch.action.search.SearchTransportService;
 import org.opensearch.action.support.TransportAction;
 import org.opensearch.action.update.UpdateHelper;
@@ -68,6 +69,8 @@
 import org.opensearch.cluster.InternalClusterInfoService;
 import org.opensearch.cluster.NodeConnectionsService;
 import org.opensearch.cluster.action.index.MappingUpdatedAction;
+import org.opensearch.cluster.applicationtemplates.SystemTemplatesPlugin;
+import org.opensearch.cluster.applicationtemplates.SystemTemplatesService;
 import org.opensearch.cluster.coordination.PersistedStateRegistry;
 import org.opensearch.cluster.metadata.AliasValidator;
 import org.opensearch.cluster.metadata.IndexTemplateMetadata;
@@ -671,11 +674,20 @@ protected Node(
             resourcesToClose.add(clusterService);
             final Set<Setting<?>> consistentSettings = settingsModule.getConsistentSettings();
             if (consistentSettings.isEmpty() == false) {
-                clusterService.addLocalNodeMasterListener(
+                clusterService.addLocalNodeClusterManagerListener(
                     new ConsistentSettingsService(settings, clusterService, consistentSettings).newHashPublisher()
                 );
             }
 
+            SystemTemplatesService systemTemplatesService = new SystemTemplatesService(
+                pluginsService.filterPlugins(SystemTemplatesPlugin.class),
+                threadPool,
+                clusterService.getClusterSettings(),
+                settings
+            );
+            systemTemplatesService.verifyRepositories();
+            clusterService.addLocalNodeClusterManagerListener(systemTemplatesService);
+
             final ClusterInfoService clusterInfoService = newClusterInfoService(settings, clusterService, threadPool, client);
             final UsageService usageService = new UsageService();
 
@@ -846,8 +858,17 @@ protected Node(
                 threadPool
             );
 
+            final TaskResourceTrackingService taskResourceTrackingService = new TaskResourceTrackingService(
+                settings,
+                clusterService.getClusterSettings(),
+                threadPool
+            );
+
             final SearchRequestStats searchRequestStats = new SearchRequestStats(clusterService.getClusterSettings());
             final SearchRequestSlowLog searchRequestSlowLog = new SearchRequestSlowLog(clusterService);
+            final SearchTaskRequestOperationsListener searchTaskRequestOperationsListener = new SearchTaskRequestOperationsListener(
+                taskResourceTrackingService
+            );
 
             remoteStoreStatsTrackerFactory = new RemoteStoreStatsTrackerFactory(clusterService, settings);
             CacheModule cacheModule = new CacheModule(pluginsService.filterPlugins(CachePlugin.class), settings);
@@ -980,7 +1001,7 @@ protected Node(
             final SearchRequestOperationsCompositeListenerFactory searchRequestOperationsCompositeListenerFactory =
                 new SearchRequestOperationsCompositeListenerFactory(
                     Stream.concat(
-                        Stream.of(searchRequestStats, searchRequestSlowLog),
+                        Stream.of(searchRequestStats, searchRequestSlowLog, searchTaskRequestOperationsListener),
                         pluginComponents.stream()
                             .filter(p -> p instanceof SearchRequestOperationsListener)
                             .map(p -> (SearchRequestOperationsListener) p)
@@ -1109,12 +1130,6 @@ protected Node(
             // development. Then we can deprecate Getter and Setter for IndexingPressureService in ClusterService (#478).
             clusterService.setIndexingPressureService(indexingPressureService);
 
-            final TaskResourceTrackingService taskResourceTrackingService = new TaskResourceTrackingService(
-                settings,
-                clusterService.getClusterSettings(),
-                threadPool
-            );
-
             final SearchBackpressureSettings searchBackpressureSettings = new SearchBackpressureSettings(
                 settings,
                 clusterService.getClusterSettings()
diff --git a/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java b/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java
index 02290b6a5e566..c4908f8c5fc4b 100644
--- a/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java
+++ b/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java
@@ -109,6 +109,7 @@
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.remote.RemoteStorePathStrategy;
+import org.opensearch.index.remote.RemoteStorePathStrategy.PathInput;
 import org.opensearch.index.snapshots.IndexShardRestoreFailedException;
 import org.opensearch.index.snapshots.IndexShardSnapshotStatus;
 import org.opensearch.index.snapshots.blobstore.BlobStoreIndexShardSnapshot;
@@ -157,6 +158,7 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.BlockingQueue;
@@ -174,6 +176,8 @@
 import java.util.stream.LongStream;
 import java.util.stream.Stream;
 
+import static org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm.FNV_1A_COMPOSITE_1;
+import static org.opensearch.index.remote.RemoteStoreEnums.PathType.HASHED_PREFIX;
 import static org.opensearch.index.snapshots.blobstore.BlobStoreIndexShardSnapshot.FileInfo.canonicalName;
 import static org.opensearch.repositories.blobstore.ChecksumBlobStoreFormat.SNAPSHOT_ONLY_FORMAT_PARAMS;
 
@@ -302,6 +306,16 @@ public abstract class BlobStoreRepository extends AbstractLifecycleComponent imp
         Setting.Property.NodeScope
     );
 
+    /**
+     * Setting to enable prefix mode verification. In this mode, a hashed string is prepended at the prefix of the base
+     * path during repository verification.
+     */
+    public static final Setting<Boolean> PREFIX_MODE_VERIFICATION_SETTING = Setting.boolSetting(
+        "prefix_mode_verification",
+        false,
+        Setting.Property.NodeScope
+    );
+
     protected volatile boolean supportURLRepo;
 
     private volatile int maxShardBlobDeleteBatch;
@@ -369,6 +383,8 @@ public abstract class BlobStoreRepository extends AbstractLifecycleComponent imp
 
     private final boolean isSystemRepository;
 
+    private final boolean prefixModeVerification;
+
     private final Object lock = new Object();
 
     private final SetOnce<BlobContainer> blobContainer = new SetOnce<>();
@@ -426,6 +442,7 @@ protected BlobStoreRepository(
         readRepositoryMetadata(repositoryMetadata);
 
         isSystemRepository = SYSTEM_REPOSITORY_SETTING.get(metadata.settings());
+        prefixModeVerification = PREFIX_MODE_VERIFICATION_SETTING.get(metadata.settings());
         this.namedXContentRegistry = namedXContentRegistry;
         this.threadPool = clusterService.getClusterApplierService().threadPool();
         this.clusterService = clusterService;
@@ -767,6 +784,10 @@ protected BlobStore getBlobStore() {
         return blobStore.get();
     }
 
+    boolean getPrefixModeVerification() {
+        return prefixModeVerification;
+    }
+
     /**
      * maintains single lazy instance of {@link BlobContainer}
      */
@@ -1918,7 +1939,7 @@ public String startVerification() {
             } else {
                 String seed = UUIDs.randomBase64UUID();
                 byte[] testBytes = Strings.toUTF8Bytes(seed);
-                BlobContainer testContainer = blobStore().blobContainer(basePath().add(testBlobPrefix(seed)));
+                BlobContainer testContainer = testContainer(seed);
                 BytesArray bytes = new BytesArray(testBytes);
                 if (isSystemRepository == false) {
                     try (InputStream stream = bytes.streamInput()) {
@@ -1936,12 +1957,26 @@ public String startVerification() {
         }
     }
 
+    /**
+     * Returns the blobContainer depending on the seed and {@code prefixModeVerification}.
+     */
+    private BlobContainer testContainer(String seed) {
+        BlobPath testBlobPath;
+        if (prefixModeVerification == true) {
+            PathInput pathInput = PathInput.builder().basePath(basePath()).indexUUID(seed).build();
+            testBlobPath = HASHED_PREFIX.path(pathInput, FNV_1A_COMPOSITE_1);
+        } else {
+            testBlobPath = basePath();
+        }
+        assert Objects.nonNull(testBlobPath);
+        return blobStore().blobContainer(testBlobPath.add(testBlobPrefix(seed)));
+    }
+
     @Override
     public void endVerification(String seed) {
         if (isReadOnly() == false) {
             try {
-                final String testPrefix = testBlobPrefix(seed);
-                blobStore().blobContainer(basePath().add(testPrefix)).delete();
+                testContainer(seed).delete();
             } catch (Exception exp) {
                 throw new RepositoryVerificationException(metadata.name(), "cannot delete test data at " + basePath(), exp);
             }
@@ -3266,7 +3301,7 @@ public void verify(String seed, DiscoveryNode localNode) {
                 );
             }
         } else {
-            BlobContainer testBlobContainer = blobStore().blobContainer(basePath().add(testBlobPrefix(seed)));
+            BlobContainer testBlobContainer = testContainer(seed);
             try {
                 BytesArray bytes = new BytesArray(seed);
                 try (InputStream stream = bytes.streamInput()) {
diff --git a/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestClusterStatsAction.java b/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestClusterStatsAction.java
index 0766e838210fa..d4426a004af8e 100644
--- a/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestClusterStatsAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestClusterStatsAction.java
@@ -66,6 +66,8 @@ public String getName() {
     public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
         ClusterStatsRequest clusterStatsRequest = new ClusterStatsRequest().nodesIds(request.paramAsStringArray("nodeId", null));
         clusterStatsRequest.timeout(request.param("timeout"));
+        clusterStatsRequest.setIncludeDiscoveryNodes(false);
+        clusterStatsRequest.useAggregatedNodeLevelResponses(true);
         return channel -> client.admin().cluster().clusterStats(clusterStatsRequest, new NodesResponseRestListener<>(channel));
     }
 
diff --git a/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesInfoAction.java b/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesInfoAction.java
index 3b83bf9d6f68c..4ac51933ea382 100644
--- a/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesInfoAction.java
@@ -88,7 +88,7 @@ public RestChannelConsumer prepareRequest(final RestRequest request, final NodeC
         final NodesInfoRequest nodesInfoRequest = prepareRequest(request);
         nodesInfoRequest.timeout(request.param("timeout"));
         settingsFilter.addFilterSettingParams(request);
-
+        nodesInfoRequest.setIncludeDiscoveryNodes(false);
         return channel -> client.admin().cluster().nodesInfo(nodesInfoRequest, new NodesResponseRestListener<>(channel));
     }
 
diff --git a/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesStatsAction.java b/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesStatsAction.java
index 267bfde576dec..ed9c0b171aa56 100644
--- a/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesStatsAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesStatsAction.java
@@ -232,6 +232,7 @@ public RestChannelConsumer prepareRequest(final RestRequest request, final NodeC
         // If no levels are passed in this results in an empty array.
         String[] levels = Strings.splitStringByCommaToArray(request.param("level"));
         nodesStatsRequest.indices().setLevels(levels);
+        nodesStatsRequest.setIncludeDiscoveryNodes(false);
 
         return channel -> client.admin().cluster().nodesStats(nodesStatsRequest, new NodesResponseRestListener<>(channel));
     }
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
index bffb50cc63401..0330fe627ccd0 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
@@ -125,6 +125,7 @@ public RestChannelConsumer doCatRequest(final RestRequest request, final NodeCli
             public void processResponse(final ClusterStateResponse clusterStateResponse) {
                 NodesInfoRequest nodesInfoRequest = new NodesInfoRequest();
                 nodesInfoRequest.timeout(request.param("timeout"));
+                nodesInfoRequest.setIncludeDiscoveryNodes(false);
                 nodesInfoRequest.clear()
                     .addMetrics(
                         NodesInfoRequest.Metric.JVM.metricName(),
@@ -137,6 +138,7 @@ public void processResponse(final ClusterStateResponse clusterStateResponse) {
                     public void processResponse(final NodesInfoResponse nodesInfoResponse) {
                         NodesStatsRequest nodesStatsRequest = new NodesStatsRequest();
                         nodesStatsRequest.timeout(request.param("timeout"));
+                        nodesStatsRequest.setIncludeDiscoveryNodes(false);
                         nodesStatsRequest.clear()
                             .indices(true)
                             .addMetrics(
diff --git a/server/src/main/java/org/opensearch/rest/action/document/RestBulkAction.java b/server/src/main/java/org/opensearch/rest/action/document/RestBulkAction.java
index 0bc4234c9b8b8..ce52c5620b968 100644
--- a/server/src/main/java/org/opensearch/rest/action/document/RestBulkAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/document/RestBulkAction.java
@@ -38,6 +38,7 @@
 import org.opensearch.action.support.ActiveShardCount;
 import org.opensearch.client.Requests;
 import org.opensearch.client.node.NodeClient;
+import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.rest.BaseRestHandler;
 import org.opensearch.rest.RestRequest;
@@ -66,6 +67,8 @@
 public class RestBulkAction extends BaseRestHandler {
 
     private final boolean allowExplicitIndex;
+    private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(RestBulkAction.class);
+    static final String BATCH_SIZE_DEPRECATED_MESSAGE = "The batch size option in bulk API is deprecated and will be removed in 3.0.";
 
     public RestBulkAction(Settings settings) {
         this.allowExplicitIndex = MULTI_ALLOW_EXPLICIT_INDEX.get(settings);
@@ -97,7 +100,10 @@ public RestChannelConsumer prepareRequest(final RestRequest request, final NodeC
         Boolean defaultRequireAlias = request.paramAsBoolean(DocWriteRequest.REQUIRE_ALIAS, null);
         bulkRequest.timeout(request.paramAsTime("timeout", BulkShardRequest.DEFAULT_TIMEOUT));
         bulkRequest.setRefreshPolicy(request.param("refresh"));
-        bulkRequest.batchSize(request.paramAsInt("batch_size", 1));
+        if (request.hasParam("batch_size")) {
+            deprecationLogger.deprecate("batch_size_deprecation", BATCH_SIZE_DEPRECATED_MESSAGE);
+        }
+        bulkRequest.batchSize(request.paramAsInt("batch_size", Integer.MAX_VALUE));
         bulkRequest.add(
             request.requiredContent(),
             defaultIndex,
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogram.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogram.java
index a27c689127ac9..a988b911de5a3 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogram.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogram.java
@@ -395,6 +395,7 @@ private void addEmptyBuckets(List<Bucket> list, ReduceContext reduceContext) {
             // fill with empty buckets
             for (double key = round(emptyBucketInfo.minBound); key <= emptyBucketInfo.maxBound; key = nextKey(key)) {
                 iter.add(new Bucket(key, 0, keyed, format, reducedEmptySubAggs));
+                reduceContext.consumeBucketsAndMaybeBreak(0);
             }
         } else {
             Bucket first = list.get(iter.nextIndex());
@@ -402,11 +403,12 @@ private void addEmptyBuckets(List<Bucket> list, ReduceContext reduceContext) {
                 // fill with empty buckets until the first key
                 for (double key = round(emptyBucketInfo.minBound); key < first.key; key = nextKey(key)) {
                     iter.add(new Bucket(key, 0, keyed, format, reducedEmptySubAggs));
+                    reduceContext.consumeBucketsAndMaybeBreak(0);
                 }
             }
 
             // now adding the empty buckets within the actual data,
-            // e.g. if the data series is [1,2,3,7] there're 3 empty buckets that will be created for 4,5,6
+            // e.g. if the data series is [1,2,3,7] there are 3 empty buckets that will be created for 4,5,6
             Bucket lastBucket = null;
             do {
                 Bucket nextBucket = list.get(iter.nextIndex());
@@ -414,6 +416,7 @@ private void addEmptyBuckets(List<Bucket> list, ReduceContext reduceContext) {
                     double key = nextKey(lastBucket.key);
                     while (key < nextBucket.key) {
                         iter.add(new Bucket(key, 0, keyed, format, reducedEmptySubAggs));
+                        reduceContext.consumeBucketsAndMaybeBreak(0);
                         key = nextKey(key);
                     }
                     assert key == nextBucket.key || Double.isNaN(nextBucket.key) : "key: " + key + ", nextBucket.key: " + nextBucket.key;
@@ -424,6 +427,7 @@ private void addEmptyBuckets(List<Bucket> list, ReduceContext reduceContext) {
             // finally, adding the empty buckets *after* the actual data (based on the extended_bounds.max requested by the user)
             for (double key = nextKey(lastBucket.key); key <= emptyBucketInfo.maxBound; key = nextKey(key)) {
                 iter.add(new Bucket(key, 0, keyed, format, reducedEmptySubAggs));
+                reduceContext.consumeBucketsAndMaybeBreak(0);
             }
         }
     }
diff --git a/server/src/test/java/org/opensearch/action/RestStatsActionTests.java b/server/src/test/java/org/opensearch/action/RestStatsActionTests.java
new file mode 100644
index 0000000000000..9b8a0640ee343
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/RestStatsActionTests.java
@@ -0,0 +1,59 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action;
+
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.settings.SettingsFilter;
+import org.opensearch.rest.action.admin.cluster.RestClusterStatsAction;
+import org.opensearch.rest.action.admin.cluster.RestNodesInfoAction;
+import org.opensearch.rest.action.admin.cluster.RestNodesStatsAction;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.test.rest.FakeRestRequest;
+import org.opensearch.threadpool.TestThreadPool;
+import org.junit.After;
+
+import java.util.Collections;
+
+public class RestStatsActionTests extends OpenSearchTestCase {
+    private final TestThreadPool threadPool = new TestThreadPool(RestStatsActionTests.class.getName());
+    private final NodeClient client = new NodeClient(Settings.EMPTY, threadPool);
+
+    @After
+    public void terminateThreadPool() {
+        terminate(threadPool);
+    }
+
+    public void testClusterStatsActionPrepareRequestNoError() {
+        RestClusterStatsAction action = new RestClusterStatsAction();
+        try {
+            action.prepareRequest(new FakeRestRequest(), client);
+        } catch (Throwable t) {
+            fail(t.getMessage());
+        }
+    }
+
+    public void testNodesStatsActionPrepareRequestNoError() {
+        RestNodesStatsAction action = new RestNodesStatsAction();
+        try {
+            action.prepareRequest(new FakeRestRequest(), client);
+        } catch (Throwable t) {
+            fail(t.getMessage());
+        }
+    }
+
+    public void testNodesInfoActionPrepareRequestNoError() {
+        RestNodesInfoAction action = new RestNodesInfoAction(new SettingsFilter(Collections.singleton("foo.filtered")));
+        try {
+            action.prepareRequest(new FakeRestRequest(), client);
+        } catch (Throwable t) {
+            fail(t.getMessage());
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodesTests.java b/server/src/test/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodesTests.java
index 40a30342b86b9..1c4a77905d73f 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodesTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodesTests.java
@@ -32,16 +32,38 @@
 
 package org.opensearch.action.admin.cluster.stats;
 
+import org.opensearch.Build;
+import org.opensearch.Version;
 import org.opensearch.action.admin.cluster.node.info.NodeInfo;
 import org.opensearch.action.admin.cluster.node.stats.NodeStats;
 import org.opensearch.action.admin.cluster.node.stats.NodeStatsTests;
+import org.opensearch.action.admin.indices.stats.CommonStats;
+import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
+import org.opensearch.action.admin.indices.stats.ShardStats;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.ShardRoutingState;
+import org.opensearch.cluster.routing.TestShardRouting;
+import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.network.NetworkModule;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.index.Index;
 import org.opensearch.core.xcontent.MediaTypeRegistry;
+import org.opensearch.index.cache.query.QueryCacheStats;
+import org.opensearch.index.engine.SegmentsStats;
+import org.opensearch.index.fielddata.FieldDataStats;
+import org.opensearch.index.flush.FlushStats;
+import org.opensearch.index.shard.DocsStats;
+import org.opensearch.index.shard.IndexingStats;
+import org.opensearch.index.shard.ShardPath;
+import org.opensearch.index.store.StoreStats;
+import org.opensearch.search.suggest.completion.CompletionStats;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.io.IOException;
+import java.nio.file.Path;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Iterator;
@@ -158,6 +180,253 @@ public void testIngestStats() throws Exception {
         );
     }
 
+    public void testMultiVersionScenarioWithAggregatedNodeLevelStats() {
+        // Assuming the default behavior will be the type of response expected from a node of version prior to version containing
+        // aggregated node level information
+        int numberOfNodes = randomIntBetween(1, 4);
+        Index testIndex = new Index("test-index", "_na_");
+
+        List<ClusterStatsNodeResponse> defaultClusterStatsNodeResponses = new ArrayList<>();
+        List<ClusterStatsNodeResponse> aggregatedNodeLevelClusterStatsNodeResponses = new ArrayList<>();
+
+        for (int i = 0; i < numberOfNodes; i++) {
+            DiscoveryNode node = new DiscoveryNode("node-" + i, buildNewFakeTransportAddress(), Version.CURRENT);
+            CommonStats commonStats = createRandomCommonStats();
+            ShardStats[] shardStats = createshardStats(node, testIndex, commonStats);
+            ClusterStatsNodeResponse customClusterStatsResponse = createClusterStatsNodeResponse(node, shardStats, testIndex, true, false);
+            ClusterStatsNodeResponse customNodeLevelAggregatedClusterStatsResponse = createClusterStatsNodeResponse(
+                node,
+                shardStats,
+                testIndex,
+                false,
+                true
+            );
+            defaultClusterStatsNodeResponses.add(customClusterStatsResponse);
+            aggregatedNodeLevelClusterStatsNodeResponses.add(customNodeLevelAggregatedClusterStatsResponse);
+        }
+
+        ClusterStatsIndices defaultClusterStatsIndices = new ClusterStatsIndices(defaultClusterStatsNodeResponses, null, null);
+        ClusterStatsIndices aggregatedNodeLevelClusterStatsIndices = new ClusterStatsIndices(
+            aggregatedNodeLevelClusterStatsNodeResponses,
+            null,
+            null
+        );
+
+        assertClusterStatsIndicesEqual(defaultClusterStatsIndices, aggregatedNodeLevelClusterStatsIndices);
+    }
+
+    public void assertClusterStatsIndicesEqual(ClusterStatsIndices first, ClusterStatsIndices second) {
+        assertEquals(first.getIndexCount(), second.getIndexCount());
+
+        assertEquals(first.getShards().getIndices(), second.getShards().getIndices());
+        assertEquals(first.getShards().getTotal(), second.getShards().getTotal());
+        assertEquals(first.getShards().getPrimaries(), second.getShards().getPrimaries());
+        assertEquals(first.getShards().getMinIndexShards(), second.getShards().getMaxIndexShards());
+        assertEquals(first.getShards().getMinIndexPrimaryShards(), second.getShards().getMinIndexPrimaryShards());
+
+        // As AssertEquals with double is deprecated and can only be used to compare floating-point numbers
+        assertTrue(first.getShards().getReplication() == second.getShards().getReplication());
+        assertTrue(first.getShards().getAvgIndexShards() == second.getShards().getAvgIndexShards());
+        assertTrue(first.getShards().getMaxIndexPrimaryShards() == second.getShards().getMaxIndexPrimaryShards());
+        assertTrue(first.getShards().getAvgIndexPrimaryShards() == second.getShards().getAvgIndexPrimaryShards());
+        assertTrue(first.getShards().getMinIndexReplication() == second.getShards().getMinIndexReplication());
+        assertTrue(first.getShards().getAvgIndexReplication() == second.getShards().getAvgIndexReplication());
+        assertTrue(first.getShards().getMaxIndexReplication() == second.getShards().getMaxIndexReplication());
+
+        // Docs stats
+        assertEquals(first.getDocs().getAverageSizeInBytes(), second.getDocs().getAverageSizeInBytes());
+        assertEquals(first.getDocs().getDeleted(), second.getDocs().getDeleted());
+        assertEquals(first.getDocs().getCount(), second.getDocs().getCount());
+        assertEquals(first.getDocs().getTotalSizeInBytes(), second.getDocs().getTotalSizeInBytes());
+
+        // Store Stats
+        assertEquals(first.getStore().getSizeInBytes(), second.getStore().getSizeInBytes());
+        assertEquals(first.getStore().getSize(), second.getStore().getSize());
+        assertEquals(first.getStore().getReservedSize(), second.getStore().getReservedSize());
+
+        // Query Cache
+        assertEquals(first.getQueryCache().getCacheCount(), second.getQueryCache().getCacheCount());
+        assertEquals(first.getQueryCache().getCacheSize(), second.getQueryCache().getCacheSize());
+        assertEquals(first.getQueryCache().getEvictions(), second.getQueryCache().getEvictions());
+        assertEquals(first.getQueryCache().getHitCount(), second.getQueryCache().getHitCount());
+        assertEquals(first.getQueryCache().getTotalCount(), second.getQueryCache().getTotalCount());
+        assertEquals(first.getQueryCache().getMissCount(), second.getQueryCache().getMissCount());
+        assertEquals(first.getQueryCache().getMemorySize(), second.getQueryCache().getMemorySize());
+        assertEquals(first.getQueryCache().getMemorySizeInBytes(), second.getQueryCache().getMemorySizeInBytes());
+
+        // Completion Stats
+        assertEquals(first.getCompletion().getSizeInBytes(), second.getCompletion().getSizeInBytes());
+        assertEquals(first.getCompletion().getSize(), second.getCompletion().getSize());
+
+        // Segment Stats
+        assertEquals(first.getSegments().getBitsetMemory(), second.getSegments().getBitsetMemory());
+        assertEquals(first.getSegments().getCount(), second.getSegments().getCount());
+        assertEquals(first.getSegments().getBitsetMemoryInBytes(), second.getSegments().getBitsetMemoryInBytes());
+        assertEquals(first.getSegments().getFileSizes(), second.getSegments().getFileSizes());
+        assertEquals(first.getSegments().getIndexWriterMemoryInBytes(), second.getSegments().getIndexWriterMemoryInBytes());
+        assertEquals(first.getSegments().getVersionMapMemory(), second.getSegments().getVersionMapMemory());
+        assertEquals(first.getSegments().getVersionMapMemoryInBytes(), second.getSegments().getVersionMapMemoryInBytes());
+    }
+
+    public void testNodeIndexShardStatsSuccessfulSerializationDeserialization() throws IOException {
+        Index testIndex = new Index("test-index", "_na_");
+
+        DiscoveryNode node = new DiscoveryNode("node", buildNewFakeTransportAddress(), Version.CURRENT);
+        CommonStats commonStats = createRandomCommonStats();
+        ShardStats[] shardStats = createshardStats(node, testIndex, commonStats);
+        ClusterStatsNodeResponse aggregatedNodeLevelClusterStatsNodeResponse = createClusterStatsNodeResponse(
+            node,
+            shardStats,
+            testIndex,
+            false,
+            true
+        );
+
+        BytesStreamOutput out = new BytesStreamOutput();
+        aggregatedNodeLevelClusterStatsNodeResponse.writeTo(out);
+        StreamInput in = out.bytes().streamInput();
+
+        ClusterStatsNodeResponse newClusterStatsNodeRequest = new ClusterStatsNodeResponse(in);
+
+        ClusterStatsIndices beforeSerialization = new ClusterStatsIndices(List.of(aggregatedNodeLevelClusterStatsNodeResponse), null, null);
+        ClusterStatsIndices afterSerialization = new ClusterStatsIndices(List.of(newClusterStatsNodeRequest), null, null);
+
+        assertClusterStatsIndicesEqual(beforeSerialization, afterSerialization);
+
+    }
+
+    private ClusterStatsNodeResponse createClusterStatsNodeResponse(
+        DiscoveryNode node,
+        ShardStats[] shardStats,
+        Index index,
+        boolean defaultBehavior,
+        boolean aggregateNodeLevelStats
+    ) {
+        NodeInfo nodeInfo = new NodeInfo(
+            Version.CURRENT,
+            Build.CURRENT,
+            node,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null
+        );
+
+        NodeStats nodeStats = new NodeStats(
+            node,
+            randomNonNegativeLong(),
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null
+        );
+        if (defaultBehavior) {
+            return new ClusterStatsNodeResponse(node, null, nodeInfo, nodeStats, shardStats);
+        } else {
+            return new ClusterStatsNodeResponse(node, null, nodeInfo, nodeStats, shardStats, aggregateNodeLevelStats);
+        }
+
+    }
+
+    private CommonStats createRandomCommonStats() {
+        CommonStats commonStats = new CommonStats(CommonStatsFlags.NONE);
+        commonStats.docs = new DocsStats(randomLongBetween(0, 10000), randomLongBetween(0, 100), randomLongBetween(0, 1000));
+        commonStats.store = new StoreStats(randomLongBetween(0, 100), randomLongBetween(0, 1000));
+        commonStats.indexing = new IndexingStats();
+        commonStats.completion = new CompletionStats();
+        commonStats.flush = new FlushStats(randomLongBetween(0, 100), randomLongBetween(0, 100), randomLongBetween(0, 100));
+        commonStats.fieldData = new FieldDataStats(randomLongBetween(0, 100), randomLongBetween(0, 100), null);
+        commonStats.queryCache = new QueryCacheStats(
+            randomLongBetween(0, 100),
+            randomLongBetween(0, 100),
+            randomLongBetween(0, 100),
+            randomLongBetween(0, 100),
+            randomLongBetween(0, 100)
+        );
+        commonStats.segments = new SegmentsStats();
+
+        return commonStats;
+    }
+
+    private ShardStats[] createshardStats(DiscoveryNode localNode, Index index, CommonStats commonStats) {
+        List<ShardStats> shardStatsList = new ArrayList<>();
+        for (int i = 0; i < 2; i++) {
+            ShardRoutingState shardRoutingState = ShardRoutingState.fromValue((byte) randomIntBetween(2, 3));
+            ShardRouting shardRouting = TestShardRouting.newShardRouting(
+                index.getName(),
+                i,
+                localNode.getId(),
+                randomBoolean(),
+                shardRoutingState
+            );
+
+            Path path = createTempDir().resolve("indices")
+                .resolve(shardRouting.shardId().getIndex().getUUID())
+                .resolve(String.valueOf(shardRouting.shardId().id()));
+
+            ShardStats shardStats = new ShardStats(
+                shardRouting,
+                new ShardPath(false, path, path, shardRouting.shardId()),
+                commonStats,
+                null,
+                null,
+                null
+            );
+            shardStatsList.add(shardStats);
+        }
+
+        return shardStatsList.toArray(new ShardStats[0]);
+    }
+
+    private class MockShardStats extends ClusterStatsIndices.ShardStats {
+        public boolean equals(ClusterStatsIndices.ShardStats shardStats) {
+            return this.getIndices() == shardStats.getIndices()
+                && this.getTotal() == shardStats.getTotal()
+                && this.getPrimaries() == shardStats.getPrimaries()
+                && this.getReplication() == shardStats.getReplication()
+                && this.getMaxIndexShards() == shardStats.getMaxIndexShards()
+                && this.getMinIndexShards() == shardStats.getMinIndexShards()
+                && this.getAvgIndexShards() == shardStats.getAvgIndexShards()
+                && this.getMaxIndexPrimaryShards() == shardStats.getMaxIndexPrimaryShards()
+                && this.getMinIndexPrimaryShards() == shardStats.getMinIndexPrimaryShards()
+                && this.getAvgIndexPrimaryShards() == shardStats.getAvgIndexPrimaryShards()
+                && this.getMinIndexReplication() == shardStats.getMinIndexReplication()
+                && this.getAvgIndexReplication() == shardStats.getAvgIndexReplication()
+                && this.getMaxIndexReplication() == shardStats.getMaxIndexReplication();
+        }
+    }
+
     private static NodeInfo createNodeInfo(String nodeId, String transportType, String httpType) {
         Settings.Builder settings = Settings.builder();
         if (transportType != null) {
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/mapping/get/GetMappingsActionTests.java b/server/src/test/java/org/opensearch/action/admin/indices/mapping/get/GetMappingsActionTests.java
new file mode 100644
index 0000000000000..87f218760038e
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/admin/indices/mapping/get/GetMappingsActionTests.java
@@ -0,0 +1,227 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.action.admin.indices.mapping.get;
+
+import org.opensearch.Version;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.clustermanager.term.GetTermVersionResponse;
+import org.opensearch.action.support.replication.ClusterStateCreationUtils;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.block.ClusterBlock;
+import org.opensearch.cluster.block.ClusterBlockException;
+import org.opensearch.cluster.block.ClusterBlockLevel;
+import org.opensearch.cluster.block.ClusterBlocks;
+import org.opensearch.cluster.coordination.ClusterStateTermVersion;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.settings.SettingsFilter;
+import org.opensearch.common.settings.SettingsModule;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.indices.IndicesService;
+import org.opensearch.telemetry.tracing.noop.NoopTracer;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.test.transport.CapturingTransport;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.concurrent.TimeUnit;
+
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptySet;
+import static org.opensearch.test.ClusterServiceUtils.createClusterService;
+import static org.opensearch.test.ClusterServiceUtils.setState;
+import static org.hamcrest.Matchers.equalTo;
+import static org.mockito.Mockito.mock;
+
+public class GetMappingsActionTests extends OpenSearchTestCase {
+    private TransportService transportService;
+    private ClusterService clusterService;
+    private ThreadPool threadPool;
+    private SettingsFilter settingsFilter;
+    private final String indexName = "test_index";
+    CapturingTransport capturingTransport = new CapturingTransport();
+    private DiscoveryNode localNode;
+    private DiscoveryNode remoteNode;
+    private DiscoveryNode[] allNodes;
+    private TransportGetMappingsAction transportAction = null;
+
+    @Before
+    public void setUp() throws Exception {
+        super.setUp();
+
+        settingsFilter = new SettingsModule(Settings.EMPTY, emptyList(), emptyList(), emptySet()).getSettingsFilter();
+        threadPool = new TestThreadPool("GetIndexActionTests");
+        clusterService = createClusterService(threadPool);
+
+        transportService = capturingTransport.createTransportService(
+            clusterService.getSettings(),
+            threadPool,
+            TransportService.NOOP_TRANSPORT_INTERCEPTOR,
+            boundAddress -> clusterService.localNode(),
+            null,
+            emptySet(),
+            NoopTracer.INSTANCE
+        );
+        transportService.start();
+        transportService.acceptIncomingRequests();
+
+        localNode = new DiscoveryNode(
+            "local_node",
+            buildNewFakeTransportAddress(),
+            Collections.emptyMap(),
+            Collections.singleton(DiscoveryNodeRole.DATA_ROLE),
+            Version.CURRENT
+        );
+        remoteNode = new DiscoveryNode(
+            "remote_node",
+            buildNewFakeTransportAddress(),
+            Collections.emptyMap(),
+            Collections.singleton(DiscoveryNodeRole.CLUSTER_MANAGER_ROLE),
+            Version.CURRENT
+        );
+        allNodes = new DiscoveryNode[] { localNode, remoteNode };
+        setState(clusterService, ClusterStateCreationUtils.state(localNode, remoteNode, allNodes));
+        transportAction = new TransportGetMappingsAction(
+            GetMappingsActionTests.this.transportService,
+            GetMappingsActionTests.this.clusterService,
+            GetMappingsActionTests.this.threadPool,
+            new ActionFilters(emptySet()),
+            new IndexNameExpressionResolver(new ThreadContext(Settings.EMPTY)),
+            mock(IndicesService.class)
+        );
+
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        clusterService.close();
+        transportService.close();
+        ThreadPool.terminate(threadPool, 30, TimeUnit.SECONDS);
+    }
+
+    public void testGetTransportWithoutMatchingTerm() {
+        transportAction.execute(null, new GetMappingsRequest(), ActionListener.wrap(Assert::assertNotNull, exception -> {
+            throw new AssertionError(exception);
+        }));
+        assertThat(capturingTransport.capturedRequests().length, equalTo(1));
+        CapturingTransport.CapturedRequest capturedRequest = capturingTransport.capturedRequests()[0];
+        // mismatch term and version
+        GetTermVersionResponse termResp = new GetTermVersionResponse(
+            new ClusterStateTermVersion(
+                clusterService.state().getClusterName(),
+                clusterService.state().metadata().clusterUUID(),
+                clusterService.state().term() - 1,
+                clusterService.state().version() - 1
+            )
+        );
+        capturingTransport.handleResponse(capturedRequest.requestId, termResp);
+
+        assertThat(capturingTransport.capturedRequests().length, equalTo(2));
+        CapturingTransport.CapturedRequest capturedRequest1 = capturingTransport.capturedRequests()[1];
+
+        capturingTransport.handleResponse(capturedRequest1.requestId, new GetMappingsResponse(new HashMap<>()));
+    }
+
+    public void testGetTransportWithMatchingTerm() {
+        transportAction.execute(null, new GetMappingsRequest(), ActionListener.wrap(Assert::assertNotNull, exception -> {
+            throw new AssertionError(exception);
+        }));
+        assertThat(capturingTransport.capturedRequests().length, equalTo(1));
+        CapturingTransport.CapturedRequest capturedRequest = capturingTransport.capturedRequests()[0];
+        GetTermVersionResponse termResp = new GetTermVersionResponse(
+            new ClusterStateTermVersion(
+                clusterService.state().getClusterName(),
+                clusterService.state().metadata().clusterUUID(),
+                clusterService.state().term(),
+                clusterService.state().version()
+            )
+        );
+        capturingTransport.handleResponse(capturedRequest.requestId, termResp);
+
+        // no more transport calls
+        assertThat(capturingTransport.capturedRequests().length, equalTo(1));
+    }
+
+    public void testGetTransportClusterBlockWithMatchingTerm() {
+        ClusterBlock readClusterBlock = new ClusterBlock(
+            1,
+            "uuid",
+            "",
+            false,
+            true,
+            true,
+            RestStatus.OK,
+            EnumSet.of(ClusterBlockLevel.METADATA_READ)
+        );
+        ClusterBlocks.Builder builder = ClusterBlocks.builder();
+        builder.addGlobalBlock(readClusterBlock);
+        ClusterState metadataReadBlockedState = ClusterState.builder(ClusterStateCreationUtils.state(localNode, remoteNode, allNodes))
+            .blocks(builder)
+            .build();
+        setState(clusterService, metadataReadBlockedState);
+
+        transportAction.execute(
+            null,
+            new GetMappingsRequest(),
+            ActionListener.wrap(response -> { throw new AssertionError(response); }, exception -> {
+                Assert.assertTrue(exception instanceof ClusterBlockException);
+            })
+        );
+        assertThat(capturingTransport.capturedRequests().length, equalTo(1));
+        CapturingTransport.CapturedRequest capturedRequest = capturingTransport.capturedRequests()[0];
+        GetTermVersionResponse termResp = new GetTermVersionResponse(
+            new ClusterStateTermVersion(
+                clusterService.state().getClusterName(),
+                clusterService.state().metadata().clusterUUID(),
+                clusterService.state().term(),
+                clusterService.state().version()
+            )
+        );
+        capturingTransport.handleResponse(capturedRequest.requestId, termResp);
+
+        // no more transport calls
+        assertThat(capturingTransport.capturedRequests().length, equalTo(1));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringResponseTests.java b/server/src/test/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringResponseTests.java
new file mode 100644
index 0000000000000..85cabe0fa1491
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringResponseTests.java
@@ -0,0 +1,101 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.common.xcontent.XContentType;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.test.AbstractWireSerializingTestCase;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class HotToWarmTieringResponseTests extends AbstractWireSerializingTestCase<HotToWarmTieringResponse> {
+
+    @Override
+    protected Writeable.Reader<HotToWarmTieringResponse> instanceReader() {
+        return HotToWarmTieringResponse::new;
+    }
+
+    @Override
+    protected HotToWarmTieringResponse createTestInstance() {
+        return randomHotToWarmTieringResponse();
+    }
+
+    @Override
+    protected void assertEqualInstances(HotToWarmTieringResponse expected, HotToWarmTieringResponse actual) {
+        assertNotSame(expected, actual);
+        assertEquals(actual.isAcknowledged(), expected.isAcknowledged());
+
+        for (int i = 0; i < expected.getFailedIndices().size(); i++) {
+            HotToWarmTieringResponse.IndexResult expectedIndexResult = expected.getFailedIndices().get(i);
+            HotToWarmTieringResponse.IndexResult actualIndexResult = actual.getFailedIndices().get(i);
+            assertNotSame(expectedIndexResult, actualIndexResult);
+            assertEquals(actualIndexResult.getIndex(), expectedIndexResult.getIndex());
+            assertEquals(actualIndexResult.getFailureReason(), expectedIndexResult.getFailureReason());
+        }
+    }
+
+    /**
+     * Verifies that ToXContent works with any random {@link HotToWarmTieringResponse} object
+     * @throws Exception - in case of error
+     */
+    public void testToXContentWorksForRandomResponse() throws Exception {
+        HotToWarmTieringResponse testResponse = randomHotToWarmTieringResponse();
+        XContentType xContentType = randomFrom(XContentType.values());
+        try (XContentBuilder builder = XContentBuilder.builder(xContentType.xContent())) {
+            testResponse.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        }
+    }
+
+    /**
+     * Verify the XContent output of the response object
+     * @throws Exception - in case of error
+     */
+    public void testToXContentOutput() throws Exception {
+        String[] indices = new String[] { "index2", "index1" };
+        String[] errorReasons = new String[] { "reason2", "reason1" };
+        List<HotToWarmTieringResponse.IndexResult> results = new LinkedList<>();
+        for (int i = 0; i < indices.length; ++i) {
+            results.add(new HotToWarmTieringResponse.IndexResult(indices[i], errorReasons[i]));
+        }
+        HotToWarmTieringResponse testResponse = new HotToWarmTieringResponse(true, results);
+
+        // generate a corresponding expected xcontent
+        XContentBuilder content = XContentFactory.jsonBuilder().startObject().field("acknowledged", true).startArray("failed_indices");
+        // expected result should be in the sorted order
+        content.startObject().field("index", "index1").field("error", "reason1").endObject();
+        content.startObject().field("index", "index2").field("error", "reason2").endObject();
+        content.endArray().endObject();
+        assertEquals(content.toString(), testResponse.toString());
+    }
+
+    /**
+     * @return - randomly generated object of type {@link HotToWarmTieringResponse.IndexResult}
+     */
+    private HotToWarmTieringResponse.IndexResult randomIndexResult() {
+        String indexName = randomAlphaOfLengthBetween(1, 50);
+        String failureReason = randomAlphaOfLengthBetween(1, 200);
+        return new HotToWarmTieringResponse.IndexResult(indexName, failureReason);
+    }
+
+    /**
+     * @return - randomly generated object of type {@link HotToWarmTieringResponse}
+     */
+    private HotToWarmTieringResponse randomHotToWarmTieringResponse() {
+        int numIndexResult = randomIntBetween(0, 10);
+        List<HotToWarmTieringResponse.IndexResult> indexResults = new LinkedList<>();
+        for (int i = 0; i < numIndexResult; ++i) {
+            indexResults.add(randomIndexResult());
+        }
+        return new HotToWarmTieringResponse(randomBoolean(), indexResults);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/tiering/TieringIndexRequestTests.java b/server/src/test/java/org/opensearch/action/admin/indices/tiering/TieringIndexRequestTests.java
new file mode 100644
index 0000000000000..e33d10268a617
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/admin/indices/tiering/TieringIndexRequestTests.java
@@ -0,0 +1,79 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.action.support.IndicesOptions;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+
+public class TieringIndexRequestTests extends OpenSearchTestCase {
+
+    public void testTieringRequestWithListOfIndices() {
+        TieringIndexRequest request = new TieringIndexRequest(
+            TieringIndexRequest.Tier.WARM,
+            IndicesOptions.fromOptions(randomBoolean(), randomBoolean(), randomBoolean(), randomBoolean()),
+            false,
+            "foo",
+            "bar",
+            "baz"
+        );
+        ActionRequestValidationException validationException = request.validate();
+        assertNull(validationException);
+    }
+
+    public void testTieringRequestWithIndexPattern() {
+        TieringIndexRequest request = new TieringIndexRequest(TieringIndexRequest.Tier.WARM.name(), "foo-*");
+        ActionRequestValidationException validationException = request.validate();
+        assertNull(validationException);
+    }
+
+    public void testTieringRequestWithNullOrEmptyIndices() {
+        TieringIndexRequest request = new TieringIndexRequest(TieringIndexRequest.Tier.WARM.name(), null, "");
+        ActionRequestValidationException validationException = request.validate();
+        assertNotNull(validationException);
+    }
+
+    public void testTieringRequestWithNotSupportedTier() {
+        TieringIndexRequest request = new TieringIndexRequest(TieringIndexRequest.Tier.HOT.name(), "test");
+        ActionRequestValidationException validationException = request.validate();
+        assertNotNull(validationException);
+    }
+
+    public void testTieringTypeFromString() {
+        expectThrows(IllegalArgumentException.class, () -> TieringIndexRequest.Tier.fromString("tier"));
+        expectThrows(IllegalArgumentException.class, () -> TieringIndexRequest.Tier.fromString(null));
+    }
+
+    public void testSerDeOfTieringRequest() throws IOException {
+        TieringIndexRequest request = new TieringIndexRequest(TieringIndexRequest.Tier.WARM.name(), "test");
+        try (BytesStreamOutput out = new BytesStreamOutput()) {
+            request.writeTo(out);
+            try (StreamInput in = out.bytes().streamInput()) {
+                final TieringIndexRequest deserializedRequest = new TieringIndexRequest(in);
+                assertEquals(request, deserializedRequest);
+            }
+        }
+    }
+
+    public void testTieringRequestEquals() {
+        final TieringIndexRequest original = new TieringIndexRequest(TieringIndexRequest.Tier.WARM.name(), "test");
+        original.indicesOptions(IndicesOptions.fromOptions(randomBoolean(), randomBoolean(), randomBoolean(), randomBoolean()));
+        final TieringIndexRequest expected = new TieringIndexRequest(TieringIndexRequest.Tier.WARM.name(), original.indices());
+        expected.indicesOptions(original.indicesOptions());
+        assertThat(expected, equalTo(original));
+        assertThat(expected.indices(), equalTo(original.indices()));
+        assertThat(expected.indicesOptions(), equalTo(original.indicesOptions()));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/tiering/TransportHotToWarmTieringActionTests.java b/server/src/test/java/org/opensearch/action/admin/indices/tiering/TransportHotToWarmTieringActionTests.java
new file mode 100644
index 0000000000000..10273366af804
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/admin/indices/tiering/TransportHotToWarmTieringActionTests.java
@@ -0,0 +1,118 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import com.carrotsearch.randomizedtesting.annotations.ThreadLeakFilters;
+
+import org.opensearch.action.support.IndicesOptions;
+import org.opensearch.cluster.ClusterInfoService;
+import org.opensearch.cluster.MockInternalClusterInfoService;
+import org.opensearch.cluster.block.ClusterBlockException;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.core.common.unit.ByteSizeUnit;
+import org.opensearch.core.common.unit.ByteSizeValue;
+import org.opensearch.index.IndexNotFoundException;
+import org.opensearch.index.store.remote.file.CleanerDaemonThreadLeakFilter;
+import org.opensearch.monitor.fs.FsInfo;
+import org.opensearch.plugins.Plugin;
+import org.opensearch.test.OpenSearchIntegTestCase;
+import org.junit.After;
+import org.junit.Before;
+
+import java.util.Collection;
+import java.util.Collections;
+
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_READ_ONLY_ALLOW_DELETE;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
+
+@ThreadLeakFilters(filters = CleanerDaemonThreadLeakFilter.class)
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0, supportsDedicatedMasters = false)
+public class TransportHotToWarmTieringActionTests extends OpenSearchIntegTestCase {
+    protected static final String TEST_IDX_1 = "test-idx-1";
+    protected static final String TEST_IDX_2 = "idx-2";
+    protected static final String TARGET_TIER = "warm";
+    private String[] indices;
+
+    @Override
+    protected Settings featureFlagSettings() {
+        Settings.Builder featureSettings = Settings.builder();
+        featureSettings.put(FeatureFlags.TIERED_REMOTE_INDEX, true);
+        return featureSettings.build();
+    }
+
+    @Override
+    protected Collection<Class<? extends Plugin>> nodePlugins() {
+        return Collections.singletonList(MockInternalClusterInfoService.TestPlugin.class);
+    }
+
+    @Before
+    public void setup() {
+        internalCluster().startClusterManagerOnlyNode();
+        internalCluster().ensureAtLeastNumSearchAndDataNodes(1);
+        long bytes = new ByteSizeValue(1000, ByteSizeUnit.KB).getBytes();
+        final MockInternalClusterInfoService clusterInfoService = getMockInternalClusterInfoService();
+        clusterInfoService.setDiskUsageFunctionAndRefresh((discoveryNode, fsInfoPath) -> setDiskUsage(fsInfoPath, bytes, bytes - 1));
+
+        final int numReplicasIndex = 0;
+        final Settings settings = Settings.builder()
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numReplicasIndex)
+            .build();
+
+        indices = new String[] { TEST_IDX_1, TEST_IDX_2 };
+        for (String index : indices) {
+            assertAcked(client().admin().indices().prepareCreate(index).setSettings(settings).get());
+            ensureGreen(index);
+        }
+    }
+
+    @After
+    public void cleanup() {
+        client().admin().indices().prepareDelete(indices).get();
+    }
+
+    MockInternalClusterInfoService getMockInternalClusterInfoService() {
+        return (MockInternalClusterInfoService) internalCluster().getCurrentClusterManagerNodeInstance(ClusterInfoService.class);
+    }
+
+    static FsInfo.Path setDiskUsage(FsInfo.Path original, long totalBytes, long freeBytes) {
+        return new FsInfo.Path(original.getPath(), original.getMount(), totalBytes, freeBytes, freeBytes);
+    }
+
+    public void testIndexLevelBlocks() {
+        enableIndexBlock(TEST_IDX_1, SETTING_READ_ONLY_ALLOW_DELETE);
+        TieringIndexRequest request = new TieringIndexRequest(TARGET_TIER, TEST_IDX_1);
+        expectThrows(ClusterBlockException.class, () -> client().execute(HotToWarmTieringAction.INSTANCE, request).actionGet());
+    }
+
+    public void testIndexNotFound() {
+        TieringIndexRequest request = new TieringIndexRequest(TARGET_TIER, "foo");
+        expectThrows(IndexNotFoundException.class, () -> client().execute(HotToWarmTieringAction.INSTANCE, request).actionGet());
+    }
+
+    public void testNoConcreteIndices() {
+        TieringIndexRequest request = new TieringIndexRequest(TARGET_TIER, "foo");
+        request.indicesOptions(IndicesOptions.fromOptions(true, true, true, false));
+        HotToWarmTieringResponse response = client().admin().indices().execute(HotToWarmTieringAction.INSTANCE, request).actionGet();
+        assertTrue(response.isAcknowledged());
+        assertTrue(response.getFailedIndices().isEmpty());
+    }
+
+    public void testNoAcceptedIndices() {
+        TieringIndexRequest request = new TieringIndexRequest(TARGET_TIER, "test-idx-*", "idx-*");
+        HotToWarmTieringResponse response = client().admin().indices().execute(HotToWarmTieringAction.INSTANCE, request).actionGet();
+        assertFalse(response.isAcknowledged());
+        assertEquals(2, response.getFailedIndices().size());
+        for (HotToWarmTieringResponse.IndexResult result : response.getFailedIndices()) {
+            assertEquals("index is not backed up by the remote store", result.getFailureReason());
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeActionTests.java b/server/src/test/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeActionTests.java
index 35c5c5e605b4d..37e884502b613 100644
--- a/server/src/test/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeActionTests.java
+++ b/server/src/test/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeActionTests.java
@@ -47,7 +47,6 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.settings.SettingsException;
 import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.action.ActionResponse;
@@ -85,8 +84,6 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import static org.opensearch.common.util.FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL;
-import static org.opensearch.index.remote.RemoteMigrationIndexMetadataUpdaterTests.createIndexMetadataWithDocrepSettings;
 import static org.opensearch.index.remote.RemoteMigrationIndexMetadataUpdaterTests.createIndexMetadataWithRemoteStoreSettings;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY;
@@ -718,9 +715,6 @@ protected void masterOperation(Task task, Request request, ClusterState state, A
     }
 
     public void testDontAllowSwitchingToStrictCompatibilityModeForMixedCluster() {
-        Settings nodeSettings = Settings.builder().put(REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
-        FeatureFlags.initializeFeatureFlags(nodeSettings);
-
         // request to change cluster compatibility mode to STRICT
         Settings currentCompatibilityModeSettings = Settings.builder()
             .put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), RemoteStoreNodeService.CompatibilityMode.MIXED)
@@ -809,84 +803,7 @@ public void testDontAllowSwitchingToStrictCompatibilityModeForMixedCluster() {
         transportClusterUpdateSettingsAction.validateCompatibilityModeSettingRequest(request, sameTypeClusterState);
     }
 
-    public void testDontAllowSwitchingToStrictCompatibilityModeWithoutRemoteIndexSettings() {
-        Settings nodeSettings = Settings.builder().put(REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
-        FeatureFlags.initializeFeatureFlags(nodeSettings);
-        Settings currentCompatibilityModeSettings = Settings.builder()
-            .put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), RemoteStoreNodeService.CompatibilityMode.MIXED)
-            .build();
-        Settings intendedCompatibilityModeSettings = Settings.builder()
-            .put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), RemoteStoreNodeService.CompatibilityMode.STRICT)
-            .build();
-        ClusterUpdateSettingsRequest request = new ClusterUpdateSettingsRequest();
-        request.persistentSettings(intendedCompatibilityModeSettings);
-        DiscoveryNode remoteNode1 = new DiscoveryNode(
-            UUIDs.base64UUID(),
-            buildNewFakeTransportAddress(),
-            getRemoteStoreNodeAttributes(),
-            DiscoveryNodeRole.BUILT_IN_ROLES,
-            Version.CURRENT
-        );
-        DiscoveryNode remoteNode2 = new DiscoveryNode(
-            UUIDs.base64UUID(),
-            buildNewFakeTransportAddress(),
-            getRemoteStoreNodeAttributes(),
-            DiscoveryNodeRole.BUILT_IN_ROLES,
-            Version.CURRENT
-        );
-        DiscoveryNodes discoveryNodes = DiscoveryNodes.builder()
-            .add(remoteNode1)
-            .localNodeId(remoteNode1.getId())
-            .add(remoteNode2)
-            .localNodeId(remoteNode2.getId())
-            .build();
-        AllocationService allocationService = new AllocationService(
-            new AllocationDeciders(Collections.singleton(new MaxRetryAllocationDecider())),
-            new TestGatewayAllocator(),
-            new BalancedShardsAllocator(Settings.EMPTY),
-            EmptyClusterInfoService.INSTANCE,
-            EmptySnapshotsInfoService.INSTANCE
-        );
-        TransportClusterUpdateSettingsAction transportClusterUpdateSettingsAction = new TransportClusterUpdateSettingsAction(
-            transportService,
-            clusterService,
-            threadPool,
-            allocationService,
-            new ActionFilters(Collections.emptySet()),
-            new IndexNameExpressionResolver(new ThreadContext(Settings.EMPTY)),
-            clusterService.getClusterSettings()
-        );
-
-        Metadata nonRemoteIndexMd = Metadata.builder(createIndexMetadataWithDocrepSettings("test"))
-            .persistentSettings(currentCompatibilityModeSettings)
-            .build();
-        final ClusterState clusterState = ClusterState.builder(ClusterName.DEFAULT)
-            .metadata(nonRemoteIndexMd)
-            .nodes(discoveryNodes)
-            .build();
-        final SettingsException exception = expectThrows(
-            SettingsException.class,
-            () -> transportClusterUpdateSettingsAction.validateCompatibilityModeSettingRequest(request, clusterState)
-        );
-        assertEquals(
-            "can not switch to STRICT compatibility mode since all indices in the cluster does not have remote store based index settings",
-            exception.getMessage()
-        );
-
-        Metadata remoteIndexMd = Metadata.builder(createIndexMetadataWithRemoteStoreSettings("test"))
-            .persistentSettings(currentCompatibilityModeSettings)
-            .build();
-        ClusterState clusterStateWithRemoteIndices = ClusterState.builder(ClusterName.DEFAULT)
-            .metadata(remoteIndexMd)
-            .nodes(discoveryNodes)
-            .build();
-        transportClusterUpdateSettingsAction.validateCompatibilityModeSettingRequest(request, clusterStateWithRemoteIndices);
-    }
-
     public void testDontAllowSwitchingCompatibilityModeForClusterWithMultipleVersions() {
-        Settings nodeSettings = Settings.builder().put(REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
-        FeatureFlags.initializeFeatureFlags(nodeSettings);
-
         // request to change cluster compatibility mode
         boolean toStrictMode = randomBoolean();
         Settings currentCompatibilityModeSettings = Settings.builder()
@@ -988,5 +905,4 @@ private Map<String, String> getRemoteStoreNodeAttributes() {
         remoteStoreNodeAttributes.put(REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY, "my-translog-repo-1");
         return remoteStoreNodeAttributes;
     }
-
 }
diff --git a/server/src/test/java/org/opensearch/action/support/nodes/TransportClusterStatsActionTests.java b/server/src/test/java/org/opensearch/action/support/nodes/TransportClusterStatsActionTests.java
new file mode 100644
index 0000000000000..f8e14b477b8ef
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/support/nodes/TransportClusterStatsActionTests.java
@@ -0,0 +1,165 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.support.nodes;
+
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
+import org.opensearch.action.admin.cluster.stats.ClusterStatsRequest;
+import org.opensearch.action.admin.cluster.stats.TransportClusterStatsAction;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.PlainActionFuture;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.indices.IndicesService;
+import org.opensearch.node.NodeService;
+import org.opensearch.test.transport.CapturingTransport;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class TransportClusterStatsActionTests extends TransportNodesActionTests {
+
+    /**
+     * By default, we send discovery nodes list to each request that is sent across from the coordinator node. This
+     * behavior is asserted in this test.
+     */
+    public void testClusterStatsActionWithRetentionOfDiscoveryNodesList() {
+        ClusterStatsRequest request = new ClusterStatsRequest();
+        request.setIncludeDiscoveryNodes(true);
+        Map<String, List<MockClusterStatsNodeRequest>> combinedSentRequest = performNodesInfoAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> {
+                assertNotNull(sentRequest.getDiscoveryNodes());
+                assertEquals(sentRequest.getDiscoveryNodes().length, clusterService.state().nodes().getSize());
+            });
+        });
+    }
+
+    public void testClusterStatsActionWithPreFilledConcreteNodesAndWithRetentionOfDiscoveryNodesList() {
+        ClusterStatsRequest request = new ClusterStatsRequest();
+        Collection<DiscoveryNode> discoveryNodes = clusterService.state().getNodes().getNodes().values();
+        request.setConcreteNodes(discoveryNodes.toArray(DiscoveryNode[]::new));
+        Map<String, List<MockClusterStatsNodeRequest>> combinedSentRequest = performNodesInfoAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> {
+                assertNotNull(sentRequest.getDiscoveryNodes());
+                assertEquals(sentRequest.getDiscoveryNodes().length, clusterService.state().nodes().getSize());
+            });
+        });
+    }
+
+    /**
+     * In the optimized ClusterStats Request, we do not send the DiscoveryNodes List to each node. This behavior is
+     * asserted in this test.
+     */
+    public void testClusterStatsActionWithoutRetentionOfDiscoveryNodesList() {
+        ClusterStatsRequest request = new ClusterStatsRequest();
+        request.setIncludeDiscoveryNodes(false);
+        Map<String, List<MockClusterStatsNodeRequest>> combinedSentRequest = performNodesInfoAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> { assertNull(sentRequest.getDiscoveryNodes()); });
+        });
+    }
+
+    public void testClusterStatsActionWithPreFilledConcreteNodesAndWithoutRetentionOfDiscoveryNodesList() {
+        ClusterStatsRequest request = new ClusterStatsRequest();
+        Collection<DiscoveryNode> discoveryNodes = clusterService.state().getNodes().getNodes().values();
+        request.setConcreteNodes(discoveryNodes.toArray(DiscoveryNode[]::new));
+        request.setIncludeDiscoveryNodes(false);
+        Map<String, List<MockClusterStatsNodeRequest>> combinedSentRequest = performNodesInfoAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> { assertNull(sentRequest.getDiscoveryNodes()); });
+        });
+    }
+
+    private Map<String, List<MockClusterStatsNodeRequest>> performNodesInfoAction(ClusterStatsRequest request) {
+        TransportNodesAction action = getTestTransportClusterStatsAction();
+        PlainActionFuture<NodesStatsRequest> listener = new PlainActionFuture<>();
+        action.new AsyncAction(null, request, listener).start();
+        Map<String, List<CapturingTransport.CapturedRequest>> capturedRequests = transport.getCapturedRequestsByTargetNodeAndClear();
+        Map<String, List<MockClusterStatsNodeRequest>> combinedSentRequest = new HashMap<>();
+
+        capturedRequests.forEach((node, capturedRequestList) -> {
+            List<MockClusterStatsNodeRequest> sentRequestList = new ArrayList<>();
+
+            capturedRequestList.forEach(preSentRequest -> {
+                BytesStreamOutput out = new BytesStreamOutput();
+                try {
+                    TransportClusterStatsAction.ClusterStatsNodeRequest clusterStatsNodeRequestFromCoordinator =
+                        (TransportClusterStatsAction.ClusterStatsNodeRequest) preSentRequest.request;
+                    clusterStatsNodeRequestFromCoordinator.writeTo(out);
+                    StreamInput in = out.bytes().streamInput();
+                    MockClusterStatsNodeRequest mockClusterStatsNodeRequest = new MockClusterStatsNodeRequest(in);
+                    sentRequestList.add(mockClusterStatsNodeRequest);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+
+            combinedSentRequest.put(node, sentRequestList);
+        });
+
+        return combinedSentRequest;
+    }
+
+    private TestTransportClusterStatsAction getTestTransportClusterStatsAction() {
+        return new TestTransportClusterStatsAction(
+            THREAD_POOL,
+            clusterService,
+            transportService,
+            nodeService,
+            indicesService,
+            new ActionFilters(Collections.emptySet())
+        );
+    }
+
+    private static class TestTransportClusterStatsAction extends TransportClusterStatsAction {
+        public TestTransportClusterStatsAction(
+            ThreadPool threadPool,
+            ClusterService clusterService,
+            TransportService transportService,
+            NodeService nodeService,
+            IndicesService indicesService,
+            ActionFilters actionFilters
+        ) {
+            super(threadPool, clusterService, transportService, nodeService, indicesService, actionFilters);
+        }
+    }
+
+    private static class MockClusterStatsNodeRequest extends TransportClusterStatsAction.ClusterStatsNodeRequest {
+
+        public MockClusterStatsNodeRequest(StreamInput in) throws IOException {
+            super(in);
+        }
+
+        public DiscoveryNode[] getDiscoveryNodes() {
+            return this.request.concreteNodes();
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesActionTests.java b/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesActionTests.java
index 445934b0ccdfd..7e968aa8fb199 100644
--- a/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesActionTests.java
+++ b/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesActionTests.java
@@ -46,6 +46,8 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.indices.IndicesService;
+import org.opensearch.node.NodeService;
 import org.opensearch.telemetry.tracing.noop.NoopTracer;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.transport.CapturingTransport;
@@ -76,11 +78,12 @@
 
 public class TransportNodesActionTests extends OpenSearchTestCase {
 
-    private static ThreadPool THREAD_POOL;
-
-    private ClusterService clusterService;
-    private CapturingTransport transport;
-    private TransportService transportService;
+    protected static ThreadPool THREAD_POOL;
+    protected ClusterService clusterService;
+    protected CapturingTransport transport;
+    protected TransportService transportService;
+    protected NodeService nodeService;
+    protected IndicesService indicesService;
 
     public void testRequestIsSentToEachNode() throws Exception {
         TransportNodesAction action = getTestTransportNodesAction();
diff --git a/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesInfoActionTests.java b/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesInfoActionTests.java
new file mode 100644
index 0000000000000..e9e09d0dbbbf9
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesInfoActionTests.java
@@ -0,0 +1,131 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.support.nodes;
+
+import org.opensearch.action.admin.cluster.node.info.NodesInfoRequest;
+import org.opensearch.action.admin.cluster.node.info.TransportNodesInfoAction;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.PlainActionFuture;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.node.NodeService;
+import org.opensearch.test.transport.CapturingTransport;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class TransportNodesInfoActionTests extends TransportNodesActionTests {
+
+    /**
+     * By default, we send discovery nodes list to each request that is sent across from the coordinator node. This
+     * behavior is asserted in this test.
+     */
+    public void testNodesInfoActionWithRetentionOfDiscoveryNodesList() {
+        NodesInfoRequest request = new NodesInfoRequest();
+        request.setIncludeDiscoveryNodes(true);
+        Map<String, List<MockNodesInfoRequest>> combinedSentRequest = performNodesInfoAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> {
+                assertNotNull(sentRequest.getDiscoveryNodes());
+                assertEquals(sentRequest.getDiscoveryNodes().length, clusterService.state().nodes().getSize());
+            });
+        });
+    }
+
+    /**
+     * In the optimized ClusterStats Request, we do not send the DiscoveryNodes List to each node. This behavior is
+     * asserted in this test.
+     */
+    public void testNodesInfoActionWithoutRetentionOfDiscoveryNodesList() {
+        NodesInfoRequest request = new NodesInfoRequest();
+        request.setIncludeDiscoveryNodes(false);
+        Map<String, List<MockNodesInfoRequest>> combinedSentRequest = performNodesInfoAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> { assertNull(sentRequest.getDiscoveryNodes()); });
+        });
+    }
+
+    private Map<String, List<MockNodesInfoRequest>> performNodesInfoAction(NodesInfoRequest request) {
+        TransportNodesAction action = getTestTransportNodesInfoAction();
+        PlainActionFuture<NodesStatsRequest> listener = new PlainActionFuture<>();
+        action.new AsyncAction(null, request, listener).start();
+        Map<String, List<CapturingTransport.CapturedRequest>> capturedRequests = transport.getCapturedRequestsByTargetNodeAndClear();
+        Map<String, List<MockNodesInfoRequest>> combinedSentRequest = new HashMap<>();
+
+        capturedRequests.forEach((node, capturedRequestList) -> {
+            List<MockNodesInfoRequest> sentRequestList = new ArrayList<>();
+
+            capturedRequestList.forEach(preSentRequest -> {
+                BytesStreamOutput out = new BytesStreamOutput();
+                try {
+                    TransportNodesInfoAction.NodeInfoRequest nodesInfoRequestFromCoordinator =
+                        (TransportNodesInfoAction.NodeInfoRequest) preSentRequest.request;
+                    nodesInfoRequestFromCoordinator.writeTo(out);
+                    StreamInput in = out.bytes().streamInput();
+                    MockNodesInfoRequest nodesStatsRequest = new MockNodesInfoRequest(in);
+                    sentRequestList.add(nodesStatsRequest);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+
+            combinedSentRequest.put(node, sentRequestList);
+        });
+
+        return combinedSentRequest;
+    }
+
+    private TestTransportNodesInfoAction getTestTransportNodesInfoAction() {
+        return new TestTransportNodesInfoAction(
+            THREAD_POOL,
+            clusterService,
+            transportService,
+            nodeService,
+            new ActionFilters(Collections.emptySet())
+        );
+    }
+
+    private static class TestTransportNodesInfoAction extends TransportNodesInfoAction {
+        public TestTransportNodesInfoAction(
+            ThreadPool threadPool,
+            ClusterService clusterService,
+            TransportService transportService,
+            NodeService nodeService,
+            ActionFilters actionFilters
+        ) {
+            super(threadPool, clusterService, transportService, nodeService, actionFilters);
+        }
+    }
+
+    private static class MockNodesInfoRequest extends TransportNodesInfoAction.NodeInfoRequest {
+
+        public MockNodesInfoRequest(StreamInput in) throws IOException {
+            super(in);
+        }
+
+        public DiscoveryNode[] getDiscoveryNodes() {
+            return this.request.concreteNodes();
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesStatsActionTests.java b/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesStatsActionTests.java
new file mode 100644
index 0000000000000..c7c420e353e1a
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesStatsActionTests.java
@@ -0,0 +1,130 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.support.nodes;
+
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
+import org.opensearch.action.admin.cluster.node.stats.TransportNodesStatsAction;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.PlainActionFuture;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.node.NodeService;
+import org.opensearch.test.transport.CapturingTransport;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class TransportNodesStatsActionTests extends TransportNodesActionTests {
+
+    /**
+     * By default, we send discovery nodes list to each request that is sent across from the coordinator node. This
+     * behavior is asserted in this test.
+     */
+    public void testNodesStatsActionWithRetentionOfDiscoveryNodesList() {
+        NodesStatsRequest request = new NodesStatsRequest();
+        request.setIncludeDiscoveryNodes(true);
+        Map<String, List<MockNodeStatsRequest>> combinedSentRequest = performNodesStatsAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> {
+                assertNotNull(sentRequest.getDiscoveryNodes());
+                assertEquals(sentRequest.getDiscoveryNodes().length, clusterService.state().nodes().getSize());
+            });
+        });
+    }
+
+    /**
+     * By default, we send discovery nodes list to each request that is sent across from the coordinator node. This
+     * behavior is asserted in this test.
+     */
+    public void testNodesStatsActionWithoutRetentionOfDiscoveryNodesList() {
+        NodesStatsRequest request = new NodesStatsRequest();
+        request.setIncludeDiscoveryNodes(false);
+        Map<String, List<MockNodeStatsRequest>> combinedSentRequest = performNodesStatsAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> { assertNull(sentRequest.getDiscoveryNodes()); });
+        });
+    }
+
+    private Map<String, List<MockNodeStatsRequest>> performNodesStatsAction(NodesStatsRequest request) {
+        TransportNodesAction action = getTestTransportNodesStatsAction();
+        PlainActionFuture<NodesStatsRequest> listener = new PlainActionFuture<>();
+        action.new AsyncAction(null, request, listener).start();
+        Map<String, List<CapturingTransport.CapturedRequest>> capturedRequests = transport.getCapturedRequestsByTargetNodeAndClear();
+        Map<String, List<MockNodeStatsRequest>> combinedSentRequest = new HashMap<>();
+
+        capturedRequests.forEach((node, capturedRequestList) -> {
+            List<MockNodeStatsRequest> sentRequestList = new ArrayList<>();
+
+            capturedRequestList.forEach(preSentRequest -> {
+                BytesStreamOutput out = new BytesStreamOutput();
+                try {
+                    TransportNodesStatsAction.NodeStatsRequest nodesStatsRequestFromCoordinator =
+                        (TransportNodesStatsAction.NodeStatsRequest) preSentRequest.request;
+                    nodesStatsRequestFromCoordinator.writeTo(out);
+                    StreamInput in = out.bytes().streamInput();
+                    MockNodeStatsRequest nodesStatsRequest = new MockNodeStatsRequest(in);
+                    sentRequestList.add(nodesStatsRequest);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+
+            combinedSentRequest.put(node, sentRequestList);
+        });
+
+        return combinedSentRequest;
+    }
+
+    private TestTransportNodesStatsAction getTestTransportNodesStatsAction() {
+        return new TestTransportNodesStatsAction(
+            THREAD_POOL,
+            clusterService,
+            transportService,
+            nodeService,
+            new ActionFilters(Collections.emptySet())
+        );
+    }
+
+    private static class TestTransportNodesStatsAction extends TransportNodesStatsAction {
+        public TestTransportNodesStatsAction(
+            ThreadPool threadPool,
+            ClusterService clusterService,
+            TransportService transportService,
+            NodeService nodeService,
+            ActionFilters actionFilters
+        ) {
+            super(threadPool, clusterService, transportService, nodeService, actionFilters);
+        }
+    }
+
+    private static class MockNodeStatsRequest extends TransportNodesStatsAction.NodeStatsRequest {
+
+        public MockNodeStatsRequest(StreamInput in) throws IOException {
+            super(in);
+        }
+
+        public DiscoveryNode[] getDiscoveryNodes() {
+            return this.request.concreteNodes();
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/update/UpdateRequestTests.java b/server/src/test/java/org/opensearch/action/update/UpdateRequestTests.java
index b70fda0d86240..e85dfa8cca556 100644
--- a/server/src/test/java/org/opensearch/action/update/UpdateRequestTests.java
+++ b/server/src/test/java/org/opensearch/action/update/UpdateRequestTests.java
@@ -247,6 +247,7 @@ public void testFromXContent() throws Exception {
         assertThat(params, notNullValue());
         assertThat(params.size(), equalTo(1));
         assertThat(params.get("param1").toString(), equalTo("value1"));
+        assertThat(request.upsertRequest().index(), equalTo("test"));
         Map<String, Object> upsertDoc = XContentHelper.convertToMap(
             request.upsertRequest().source(),
             true,
@@ -304,6 +305,7 @@ public void testFromXContent() throws Exception {
             )
         );
         Map<String, Object> doc = request.doc().sourceAsMap();
+        assertThat(request.doc().index(), equalTo("test"));
         assertThat(doc.get("field1").toString(), equalTo("value1"));
         assertThat(((Map<String, Object>) doc.get("compound")).get("field2").toString(), equalTo("value2"));
     }
@@ -662,7 +664,7 @@ public void testToString() throws IOException {
             request.toString(),
             equalTo(
                 "update {[test][1], doc_as_upsert[false], "
-                    + "doc[index {[null][null], source[{\"body\":\"bar\"}]}], scripted_upsert[false], detect_noop[true]}"
+                    + "doc[index {[test][null], source[{\"body\":\"bar\"}]}], scripted_upsert[false], detect_noop[true]}"
             )
         );
     }
diff --git a/server/src/test/java/org/opensearch/cluster/applicationtemplates/ClusterStateSystemTemplateLoaderTests.java b/server/src/test/java/org/opensearch/cluster/applicationtemplates/ClusterStateSystemTemplateLoaderTests.java
new file mode 100644
index 0000000000000..c7cfab6d38e04
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/applicationtemplates/ClusterStateSystemTemplateLoaderTests.java
@@ -0,0 +1,153 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.OpenSearchCorruptionException;
+import org.opensearch.cluster.metadata.ComponentTemplate;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.common.bytes.BytesArray;
+import org.opensearch.core.xcontent.DeprecationHandler;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.test.OpenSearchSingleNodeTestCase;
+
+import java.io.IOException;
+import java.util.UUID;
+
+public class ClusterStateSystemTemplateLoaderTests extends OpenSearchSingleNodeTestCase {
+
+    public static final String SAMPLE_TEMPLATE = "{\n"
+        + "  \"template\": {\n"
+        + "    \"settings\": {\n"
+        + "       \"index\": {\n"
+        + "           \"codec\": \"best_compression\",\n"
+        + "           \"merge.policy\": \"log_byte_size\",\n"
+        + "           \"refresh_interval\": \"60s\"\n"
+        + "       }\n"
+        + "    }\n"
+        + "  },\n"
+        + "  \"_meta\": {\n"
+        + "    \"_type\": \"@abc_template\",\n"
+        + "    \"_version\": 1\n"
+        + "  },\n"
+        + "  \"version\": 1\n"
+        + "}";
+
+    public static final String SAMPLE_TEMPLATE_V2 = "{\n"
+        + "  \"template\": {\n"
+        + "    \"settings\": {\n"
+        + "       \"index\": {\n"
+        + "           \"codec\": \"best_compression\",\n"
+        + "           \"merge.policy\": \"log_byte_size\",\n"
+        + "           \"refresh_interval\": \"60s\"\n"
+        + "       }\n"
+        + "    }\n"
+        + "  },\n"
+        + "  \"_meta\": {\n"
+        + "    \"_type\": \"@abc_template\",\n"
+        + "    \"_version\": 2\n"
+        + "  },\n"
+        + "  \"version\": 2\n"
+        + "}";
+
+    public void testLoadTemplate() throws IOException {
+        ClusterStateSystemTemplateLoader loader = new ClusterStateSystemTemplateLoader(
+            node().client(),
+            () -> node().injector().getInstance(ClusterService.class).state()
+        );
+
+        TemplateRepositoryMetadata repositoryMetadata = new TemplateRepositoryMetadata(UUID.randomUUID().toString(), 1L);
+        SystemTemplateMetadata metadata = SystemTemplateMetadata.fromComponentTemplateInfo("dummy", 1L);
+
+        // Load for the first time
+        assertTrue(
+            loader.loadTemplate(
+                new SystemTemplate(
+                    new BytesArray(SAMPLE_TEMPLATE),
+                    metadata,
+                    new TemplateRepositoryMetadata(UUID.randomUUID().toString(), 1L)
+                )
+            )
+        );
+        assertTrue(
+            node().injector()
+                .getInstance(ClusterService.class)
+                .state()
+                .metadata()
+                .componentTemplates()
+                .containsKey(metadata.fullyQualifiedName())
+        );
+        XContentParser parser = JsonXContent.jsonXContent.createParser(
+            NamedXContentRegistry.EMPTY,
+            DeprecationHandler.IGNORE_DEPRECATIONS,
+            SAMPLE_TEMPLATE
+        );
+        assertEquals(
+            node().injector().getInstance(ClusterService.class).state().metadata().componentTemplates().get(metadata.fullyQualifiedName()),
+            ComponentTemplate.parse(parser)
+        );
+
+        // Retry and ensure loading does not happen again with same version
+        assertFalse(
+            loader.loadTemplate(
+                new SystemTemplate(
+                    new BytesArray(SAMPLE_TEMPLATE),
+                    metadata,
+                    new TemplateRepositoryMetadata(UUID.randomUUID().toString(), 1L)
+                )
+            )
+        );
+
+        // Retry with new template version
+        SystemTemplateMetadata newVersionMetadata = SystemTemplateMetadata.fromComponentTemplateInfo("dummy", 2L);
+        assertTrue(loader.loadTemplate(new SystemTemplate(new BytesArray(SAMPLE_TEMPLATE_V2), newVersionMetadata, repositoryMetadata)));
+        parser = JsonXContent.jsonXContent.createParser(
+            NamedXContentRegistry.EMPTY,
+            DeprecationHandler.IGNORE_DEPRECATIONS,
+            SAMPLE_TEMPLATE_V2
+        );
+        assertEquals(
+            node().injector()
+                .getInstance(ClusterService.class)
+                .state()
+                .metadata()
+                .componentTemplates()
+                .get(newVersionMetadata.fullyQualifiedName()),
+            ComponentTemplate.parse(parser)
+        );
+    }
+
+    public void testLoadTemplateVersionMismatch() throws IOException {
+        ClusterStateSystemTemplateLoader loader = new ClusterStateSystemTemplateLoader(
+            node().client(),
+            () -> node().injector().getInstance(ClusterService.class).state()
+        );
+
+        TemplateRepositoryMetadata repositoryMetadata = new TemplateRepositoryMetadata(UUID.randomUUID().toString(), 1L);
+        SystemTemplateMetadata metadata = SystemTemplateMetadata.fromComponentTemplateInfo("dummy", 2L);
+
+        // Load for the first time
+        assertThrows(
+            OpenSearchCorruptionException.class,
+            () -> loader.loadTemplate(
+                new SystemTemplate(
+                    new BytesArray(SAMPLE_TEMPLATE),
+                    metadata,
+                    new TemplateRepositoryMetadata(UUID.randomUUID().toString(), 1L)
+                )
+            )
+        );
+    }
+
+    @Override
+    protected boolean resetNodeAfterTest() {
+        return true;
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesServiceTests.java b/server/src/test/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesServiceTests.java
new file mode 100644
index 0000000000000..4addf3802b40d
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesServiceTests.java
@@ -0,0 +1,90 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.cluster.service.applicationtemplates.TestSystemTemplatesRepositoryPlugin;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.common.util.concurrent.OpenSearchExecutors;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.mockito.Mockito;
+
+import static org.opensearch.common.settings.ClusterSettings.BUILT_IN_CLUSTER_SETTINGS;
+import static org.mockito.Mockito.when;
+
+public class SystemTemplatesServiceTests extends OpenSearchTestCase {
+
+    private SystemTemplatesService systemTemplatesService;
+
+    public void testSystemTemplatesLoaded() throws IOException {
+        setupService(true);
+
+        systemTemplatesService.onClusterManager();
+        SystemTemplatesService.Stats stats = systemTemplatesService.stats();
+        assertNotNull(stats);
+        assertEquals(stats.getTemplatesLoaded(), 1L);
+        assertEquals(stats.getFailedLoadingTemplates(), 0L);
+        assertEquals(stats.getFailedLoadingRepositories(), 1L);
+    }
+
+    public void testSystemTemplatesVerify() throws IOException {
+        setupService(false);
+
+        systemTemplatesService.verifyRepositories();
+
+        SystemTemplatesService.Stats stats = systemTemplatesService.stats();
+        assertNotNull(stats);
+        assertEquals(stats.getTemplatesLoaded(), 0L);
+        assertEquals(stats.getFailedLoadingTemplates(), 0L);
+        assertEquals(stats.getFailedLoadingRepositories(), 0L);
+    }
+
+    public void testSystemTemplatesVerifyWithFailingRepository() throws IOException {
+        setupService(true);
+
+        assertThrows(IllegalStateException.class, () -> systemTemplatesService.verifyRepositories());
+
+        SystemTemplatesService.Stats stats = systemTemplatesService.stats();
+        assertNotNull(stats);
+        assertEquals(stats.getTemplatesLoaded(), 0L);
+        assertEquals(stats.getFailedLoadingTemplates(), 0L);
+        assertEquals(stats.getFailedLoadingRepositories(), 1L);
+    }
+
+    void setupService(boolean errorFromMockPlugin) throws IOException {
+        FeatureFlags.initializeFeatureFlags(Settings.builder().put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES, true).build());
+
+        ThreadPool mockPool = Mockito.mock(ThreadPool.class);
+        when(mockPool.generic()).thenReturn(OpenSearchExecutors.newDirectExecutorService());
+
+        List<SystemTemplatesPlugin> plugins = new ArrayList<>();
+        plugins.add(new TestSystemTemplatesRepositoryPlugin());
+
+        if (errorFromMockPlugin) {
+            SystemTemplatesPlugin mockPlugin = Mockito.mock(SystemTemplatesPlugin.class);
+            when(mockPlugin.loadRepository()).thenThrow(new IOException());
+            plugins.add(mockPlugin);
+        }
+
+        ClusterSettings mockSettings = new ClusterSettings(Settings.EMPTY, BUILT_IN_CLUSTER_SETTINGS);
+        systemTemplatesService = new SystemTemplatesService(
+            plugins,
+            mockPool,
+            mockSettings,
+            Settings.builder().put(SystemTemplatesService.SETTING_APPLICATION_BASED_CONFIGURATION_TEMPLATES_ENABLED.getKey(), true).build()
+        );
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/PersistedStateStatsTests.java b/server/src/test/java/org/opensearch/cluster/coordination/PersistedStateStatsTests.java
new file mode 100644
index 0000000000000..15c7d3ea206ef
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/coordination/PersistedStateStatsTests.java
@@ -0,0 +1,62 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.coordination;
+
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+public class PersistedStateStatsTests extends OpenSearchTestCase {
+    private PersistedStateStats persistedStateStats;
+
+    @Before
+    public void setup() {
+        persistedStateStats = new PersistedStateStats("testStats");
+    }
+
+    public void testAddToExtendedFieldsNewField() {
+        String fieldName = "testField";
+        AtomicLong fieldValue = new AtomicLong(42);
+
+        persistedStateStats.addToExtendedFields(fieldName, fieldValue);
+
+        assertTrue(persistedStateStats.getExtendedFields().containsKey(fieldName));
+        assertEquals(42, persistedStateStats.getExtendedFields().get(fieldName).get());
+    }
+
+    public void testAddToExtendedFieldsExistingField() {
+        String fieldName = "testField";
+        AtomicLong initialValue = new AtomicLong(42);
+        persistedStateStats.addToExtendedFields(fieldName, initialValue);
+
+        AtomicLong newValue = new AtomicLong(84);
+        persistedStateStats.addToExtendedFields(fieldName, newValue);
+
+        assertTrue(persistedStateStats.getExtendedFields().containsKey(fieldName));
+        assertEquals(84, persistedStateStats.getExtendedFields().get(fieldName).get());
+    }
+
+    public void testAddMultipleFields() {
+        String fieldName1 = "testField1";
+        AtomicLong fieldValue1 = new AtomicLong(42);
+
+        String fieldName2 = "testField2";
+        AtomicLong fieldValue2 = new AtomicLong(84);
+
+        persistedStateStats.addToExtendedFields(fieldName1, fieldValue1);
+        persistedStateStats.addToExtendedFields(fieldName2, fieldValue2);
+
+        assertTrue(persistedStateStats.getExtendedFields().containsKey(fieldName1));
+        assertTrue(persistedStateStats.getExtendedFields().containsKey(fieldName2));
+
+        assertEquals(42, persistedStateStats.getExtendedFields().get(fieldName1).get());
+        assertEquals(84, persistedStateStats.getExtendedFields().get(fieldName2).get());
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/metadata/MetadataCreateIndexServiceTests.java b/server/src/test/java/org/opensearch/cluster/metadata/MetadataCreateIndexServiceTests.java
index 0d86cfcca389c..86ca8b3ad6319 100644
--- a/server/src/test/java/org/opensearch/cluster/metadata/MetadataCreateIndexServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/metadata/MetadataCreateIndexServiceTests.java
@@ -2151,6 +2151,33 @@ public void testAsyncDurabilityThrowsExceptionWhenRestrictSettingTrue() {
         );
     }
 
+    public void testAggregateIndexSettingsIndexReplicaIsSetToNull() {
+        // This checks that aggregateIndexSettings works for the case when the index setting `index.number_of_replicas` is set to null
+        request = new CreateIndexClusterStateUpdateRequest("create index", "test", "test");
+        request.settings(Settings.builder().putNull(SETTING_NUMBER_OF_REPLICAS).build());
+        Integer clusterDefaultReplicaNumber = 5;
+        Metadata metadata = new Metadata.Builder().persistentSettings(
+            Settings.builder().put("cluster.default_number_of_replicas", clusterDefaultReplicaNumber).build()
+        ).build();
+        ClusterState clusterState = ClusterState.builder(org.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .build();
+        Settings settings = Settings.builder().put(CLUSTER_REMOTE_INDEX_RESTRICT_ASYNC_DURABILITY_SETTING.getKey(), true).build();
+        clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        Settings aggregatedSettings = aggregateIndexSettings(
+            clusterState,
+            request,
+            Settings.EMPTY,
+            null,
+            Settings.EMPTY,
+            IndexScopedSettings.DEFAULT_SCOPED_SETTINGS,
+            randomShardLimitService(),
+            Collections.emptySet(),
+            clusterSettings
+        );
+        assertEquals(clusterDefaultReplicaNumber.toString(), aggregatedSettings.get(SETTING_NUMBER_OF_REPLICAS));
+    }
+
     public void testRequestDurabilityWhenRestrictSettingTrue() {
         // This checks that aggregateIndexSettings works for the case when the cluster setting
         // cluster.remote_store.index.restrict.async-durability is false or not set, it allows all types of durability modes
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/AllocationConstraintsTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/AllocationConstraintsTests.java
index 90546620e9e3e..4c9fcd1650664 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/allocation/AllocationConstraintsTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/AllocationConstraintsTests.java
@@ -93,7 +93,7 @@ public void testPerIndexPrimaryShardsConstraint() {
 
         assertEquals(0, constraints.weight(balancer, node, indexName));
 
-        perIndexPrimaryShardCount = 3;
+        perIndexPrimaryShardCount = 2;
         when(node.numPrimaryShards(anyString())).thenReturn(perIndexPrimaryShardCount);
         assertEquals(CONSTRAINT_WEIGHT, constraints.weight(balancer, node, indexName));
 
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDeciderTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDeciderTests.java
index 652633e689b93..2e24640fe858d 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDeciderTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDeciderTests.java
@@ -863,19 +863,6 @@ public void testUnknownDiskUsage() {
         assertThat(clusterState.getRoutingNodes().node("node1").size(), equalTo(1));
     }
 
-    public void testAverageUsage() {
-        RoutingNode rn = new RoutingNode("node1", newNode("node1"));
-        DiskThresholdDecider decider = makeDecider(Settings.EMPTY);
-
-        final Map<String, DiskUsage> usages = new HashMap<>();
-        usages.put("node2", new DiskUsage("node2", "n2", "/dev/null", 100, 50)); // 50% used
-        usages.put("node3", new DiskUsage("node3", "n3", "/dev/null", 100, 0));  // 100% used
-
-        DiskUsage node1Usage = decider.averageUsage(rn, usages);
-        assertThat(node1Usage.getTotalBytes(), equalTo(100L));
-        assertThat(node1Usage.getFreeBytes(), equalTo(25L));
-    }
-
     public void testFreeDiskPercentageAfterShardAssigned() {
         DiskThresholdDecider decider = makeDecider(Settings.EMPTY);
 
diff --git a/server/src/test/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceFactoryTests.java b/server/src/test/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceFactoryTests.java
index 39294ee8da41e..86f4b9502d6ab 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceFactoryTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceFactoryTests.java
@@ -40,7 +40,8 @@ public void testGetServiceWhenRemoteRoutingDisabled() {
             repositoriesService,
             settings,
             new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
-            threadPool
+            threadPool,
+            "test-cluster"
         );
         assertTrue(service instanceof NoopRemoteRoutingTableService);
     }
@@ -56,7 +57,8 @@ public void testGetServiceWhenRemoteRoutingEnabled() {
             repositoriesService,
             settings,
             new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
-            threadPool
+            threadPool,
+            "test-cluster"
         );
         assertTrue(service instanceof InternalRemoteRoutingTableService);
     }
diff --git a/server/src/test/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceTests.java b/server/src/test/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceTests.java
index 839ebe1ff8301..74254f1a1987f 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceTests.java
@@ -12,34 +12,35 @@
 import org.opensearch.action.LatchedActionListener;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.Diff;
 import org.opensearch.cluster.DiffableUtils;
 import org.opensearch.cluster.coordination.CoordinationMetadata;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.IndexShardRoutingTable;
 import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.RoutingTableIncrementalDiff;
 import org.opensearch.cluster.service.ClusterService;
-import org.opensearch.common.CheckedRunnable;
-import org.opensearch.common.blobstore.AsyncMultiStreamBlobContainer;
 import org.opensearch.common.blobstore.BlobContainer;
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.blobstore.BlobStore;
-import org.opensearch.common.blobstore.stream.write.WriteContext;
 import org.opensearch.common.blobstore.stream.write.WritePriority;
 import org.opensearch.common.compress.DeflateCompressor;
-import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.common.util.TestCapturingListener;
 import org.opensearch.core.action.ActionListener;
-import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
 import org.opensearch.core.index.Index;
 import org.opensearch.gateway.remote.ClusterMetadataManifest;
-import org.opensearch.gateway.remote.RemoteStateTransferException;
-import org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
 import org.opensearch.index.remote.RemoteStoreEnums;
 import org.opensearch.index.remote.RemoteStorePathStrategy;
 import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
 import org.opensearch.repositories.FilterRepository;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.RepositoryMissingException;
@@ -51,33 +52,44 @@
 import org.junit.Before;
 
 import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Base64;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
 import java.util.function.Supplier;
 
-import org.mockito.ArgumentCaptor;
 import org.mockito.Mockito;
 
-import static org.opensearch.cluster.routing.remote.InternalRemoteRoutingTableService.INDEX_ROUTING_FILE_PREFIX;
-import static org.opensearch.cluster.routing.remote.InternalRemoteRoutingTableService.INDEX_ROUTING_PATH_TOKEN;
 import static org.opensearch.common.util.FeatureFlags.REMOTE_PUBLICATION_EXPERIMENTAL;
 import static org.opensearch.gateway.remote.ClusterMetadataManifestTests.randomUploadedIndexMetadataList;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN;
 import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.PATH_DELIMITER;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_FILE;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_METADATA_PREFIX;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_TABLE;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_TABLE_FORMAT;
+import static org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff.REMOTE_ROUTING_TABLE_DIFF_FORMAT;
+import static org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_FILE;
+import static org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_METADATA_PREFIX;
+import static org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_PATH_TOKEN;
+import static org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64;
+import static org.opensearch.index.remote.RemoteStoreEnums.PathType.HASHED_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
-import static org.mockito.ArgumentMatchers.anyLong;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.ArgumentMatchers.startsWith;
 import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -92,6 +104,8 @@ public class RemoteRoutingTableServiceTests extends OpenSearchTestCase {
     private BlobPath basePath;
     private ClusterSettings clusterSettings;
     private ClusterService clusterService;
+    private Compressor compressor;
+    private BlobStoreTransferService blobStoreTransferService;
     private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
 
     @Before
@@ -105,6 +119,7 @@ public void setup() {
             .build();
         clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
         clusterService = mock(ClusterService.class);
+        blobStoreTransferService = mock(BlobStoreTransferService.class);
         when(clusterService.getClusterSettings()).thenReturn(clusterSettings);
         blobStoreRepository = mock(BlobStoreRepository.class);
         when(blobStoreRepository.getCompressor()).thenReturn(new DeflateCompressor());
@@ -112,18 +127,20 @@ public void setup() {
         blobContainer = mock(BlobContainer.class);
         when(repositoriesService.repository("routing_repository")).thenReturn(blobStoreRepository);
         when(blobStoreRepository.blobStore()).thenReturn(blobStore);
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
         Settings nodeSettings = Settings.builder().put(REMOTE_PUBLICATION_EXPERIMENTAL, "true").build();
         FeatureFlags.initializeFeatureFlags(nodeSettings);
-
+        compressor = new NoneCompressor();
         basePath = BlobPath.cleanPath().add("base-path");
-
+        when(blobStoreRepository.basePath()).thenReturn(basePath);
         remoteRoutingTableService = new InternalRemoteRoutingTableService(
             repositoriesServiceSupplier,
             settings,
             new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
-            threadPool
+            threadPool,
+            "test-cluster"
         );
-
+        remoteRoutingTableService.doStart();
     }
 
     @After
@@ -141,7 +158,8 @@ public void testFailInitializationWhenRemoteRoutingDisabled() {
                 repositoriesServiceSupplier,
                 settings,
                 new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
-                threadPool
+                threadPool,
+                "test-cluster"
             )
         );
     }
@@ -273,10 +291,14 @@ public void testGetIndicesRoutingMapDiffShardChanged() {
 
         DiffableUtils.MapDiff<String, IndexRoutingTable, Map<String, IndexRoutingTable>> diff = remoteRoutingTableService
             .getIndicesRoutingMapDiff(routingTable, routingTable2);
-        assertEquals(1, diff.getUpserts().size());
-        assertNotNull(diff.getUpserts().get(indexName));
-        assertEquals(noOfShards + 1, diff.getUpserts().get(indexName).getShards().size());
-        assertEquals(noOfReplicas + 1, diff.getUpserts().get(indexName).getShards().get(0).getSize());
+        assertEquals(0, diff.getUpserts().size());
+        assertEquals(1, diff.getDiffs().size());
+        assertNotNull(diff.getDiffs().get(indexName));
+        assertEquals(noOfShards + 1, diff.getDiffs().get(indexName).apply(routingTable.indicesRouting().get(indexName)).shards().size());
+        assertEquals(
+            noOfReplicas + 1,
+            diff.getDiffs().get(indexName).apply(routingTable.indicesRouting().get(indexName)).getShards().get(0).getSize()
+        );
         assertEquals(0, diff.getDeletes().size());
 
         final IndexMetadata indexMetadata3 = new IndexMetadata.Builder(indexName).settings(
@@ -288,11 +310,14 @@ public void testGetIndicesRoutingMapDiffShardChanged() {
         RoutingTable routingTable3 = RoutingTable.builder().addAsNew(indexMetadata3).build();
 
         diff = remoteRoutingTableService.getIndicesRoutingMapDiff(routingTable2, routingTable3);
-        assertEquals(1, diff.getUpserts().size());
-        assertNotNull(diff.getUpserts().get(indexName));
-        assertEquals(noOfShards + 1, diff.getUpserts().get(indexName).getShards().size());
-        assertEquals(noOfReplicas + 2, diff.getUpserts().get(indexName).getShards().get(0).getSize());
-
+        assertEquals(0, diff.getUpserts().size());
+        assertEquals(1, diff.getDiffs().size());
+        assertNotNull(diff.getDiffs().get(indexName));
+        assertEquals(noOfShards + 1, diff.getDiffs().get(indexName).apply(routingTable.indicesRouting().get(indexName)).shards().size());
+        assertEquals(
+            noOfReplicas + 2,
+            diff.getDiffs().get(indexName).apply(routingTable.indicesRouting().get(indexName)).getShards().get(0).getSize()
+        );
         assertEquals(0, diff.getDeletes().size());
     }
 
@@ -312,10 +337,10 @@ public void testGetIndicesRoutingMapDiffShardDetailChanged() {
 
         DiffableUtils.MapDiff<String, IndexRoutingTable, Map<String, IndexRoutingTable>> diff = remoteRoutingTableService
             .getIndicesRoutingMapDiff(routingTable, routingTable2);
-        assertEquals(1, diff.getUpserts().size());
-        assertNotNull(diff.getUpserts().get(indexName));
-        assertEquals(noOfShards, diff.getUpserts().get(indexName).getShards().size());
-        assertEquals(noOfReplicas + 1, diff.getUpserts().get(indexName).getShards().get(0).getSize());
+        assertEquals(1, diff.getDiffs().size());
+        assertNotNull(diff.getDiffs().get(indexName));
+        assertEquals(noOfShards, diff.getDiffs().get(indexName).apply(routingTable.indicesRouting().get(indexName)).shards().size());
+        assertEquals(0, diff.getUpserts().size());
         assertEquals(0, diff.getDeletes().size());
     }
 
@@ -347,136 +372,13 @@ public void testGetIndicesRoutingMapDiffIndexDeleted() {
         assertEquals(indexName, diff.getDeletes().get(0));
     }
 
-    public void testGetIndexRoutingAsyncAction() throws IOException {
-        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
-        ClusterState clusterState = createClusterState(indexName);
-        BlobPath expectedPath = getPath();
-
-        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> listener = mock(LatchedActionListener.class);
-        when(blobStore.blobContainer(expectedPath)).thenReturn(blobContainer);
-
-        remoteRoutingTableService.start();
-        CheckedRunnable<IOException> runnable = remoteRoutingTableService.getIndexRoutingAsyncAction(
-            clusterState,
-            clusterState.routingTable().getIndicesRouting().get(indexName),
-            listener,
-            basePath
-        );
-        assertNotNull(runnable);
-        runnable.run();
-
-        String expectedFilePrefix = String.join(
-            DELIMITER,
-            INDEX_ROUTING_FILE_PREFIX,
-            RemoteStoreUtils.invertLong(clusterState.term()),
-            RemoteStoreUtils.invertLong(clusterState.version())
-        );
-        verify(blobContainer, times(1)).writeBlob(startsWith(expectedFilePrefix), any(StreamInput.class), anyLong(), eq(true));
-        verify(listener, times(1)).onResponse(any(ClusterMetadataManifest.UploadedMetadata.class));
-    }
-
-    public void testGetIndexRoutingAsyncActionFailureInBlobRepo() throws IOException {
-        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
-        ClusterState clusterState = createClusterState(indexName);
-        BlobPath expectedPath = getPath();
-
-        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> listener = mock(LatchedActionListener.class);
-        when(blobStore.blobContainer(expectedPath)).thenReturn(blobContainer);
-        doThrow(new IOException("testing failure")).when(blobContainer).writeBlob(anyString(), any(StreamInput.class), anyLong(), eq(true));
-
-        remoteRoutingTableService.start();
-        CheckedRunnable<IOException> runnable = remoteRoutingTableService.getIndexRoutingAsyncAction(
-            clusterState,
-            clusterState.routingTable().getIndicesRouting().get(indexName),
-            listener,
-            basePath
-        );
-        assertNotNull(runnable);
-        runnable.run();
-        String expectedFilePrefix = String.join(
-            DELIMITER,
-            INDEX_ROUTING_FILE_PREFIX,
-            RemoteStoreUtils.invertLong(clusterState.term()),
-            RemoteStoreUtils.invertLong(clusterState.version())
-        );
-        verify(blobContainer, times(1)).writeBlob(startsWith(expectedFilePrefix), any(StreamInput.class), anyLong(), eq(true));
-        verify(listener, times(1)).onFailure(any(RemoteStateTransferException.class));
-    }
-
-    public void testGetIndexRoutingAsyncActionAsyncRepo() throws IOException {
-        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
-        ClusterState clusterState = createClusterState(indexName);
-        BlobPath expectedPath = getPath();
-
-        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> listener = mock(LatchedActionListener.class);
-        blobContainer = mock(AsyncMultiStreamBlobContainer.class);
-        when(blobStore.blobContainer(expectedPath)).thenReturn(blobContainer);
-        ArgumentCaptor<ActionListener<Void>> actionListenerArgumentCaptor = ArgumentCaptor.forClass(ActionListener.class);
-        ArgumentCaptor<WriteContext> writeContextArgumentCaptor = ArgumentCaptor.forClass(WriteContext.class);
-        ConcurrentHashMap<String, WriteContext> capturedWriteContext = new ConcurrentHashMap<>();
-
-        doAnswer((i) -> {
-            actionListenerArgumentCaptor.getValue().onResponse(null);
-            WriteContext writeContext = writeContextArgumentCaptor.getValue();
-            capturedWriteContext.put(writeContext.getFileName().split(DELIMITER)[0], writeContextArgumentCaptor.getValue());
-            return null;
-        }).when((AsyncMultiStreamBlobContainer) blobContainer)
-            .asyncBlobUpload(writeContextArgumentCaptor.capture(), actionListenerArgumentCaptor.capture());
-
-        remoteRoutingTableService.start();
-        CheckedRunnable<IOException> runnable = remoteRoutingTableService.getIndexRoutingAsyncAction(
-            clusterState,
-            clusterState.routingTable().getIndicesRouting().get(indexName),
-            listener,
-            basePath
-        );
-        assertNotNull(runnable);
-        runnable.run();
-
-        String expectedFilePrefix = String.join(
-            DELIMITER,
-            INDEX_ROUTING_FILE_PREFIX,
-            RemoteStoreUtils.invertLong(clusterState.term()),
-            RemoteStoreUtils.invertLong(clusterState.version())
-        );
-        assertEquals(1, actionListenerArgumentCaptor.getAllValues().size());
-        assertEquals(1, writeContextArgumentCaptor.getAllValues().size());
-        assertNotNull(capturedWriteContext.get("index_routing"));
-        assertEquals(capturedWriteContext.get("index_routing").getWritePriority(), WritePriority.URGENT);
-        assertTrue(capturedWriteContext.get("index_routing").getFileName().startsWith(expectedFilePrefix));
-    }
-
-    public void testGetIndexRoutingAsyncActionAsyncRepoFailureInRepo() throws IOException {
-        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
-        ClusterState clusterState = createClusterState(indexName);
-        BlobPath expectedPath = getPath();
-
-        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> listener = mock(LatchedActionListener.class);
-        blobContainer = mock(AsyncMultiStreamBlobContainer.class);
-        when(blobStore.blobContainer(expectedPath)).thenReturn(blobContainer);
-
-        doThrow(new IOException("Testing failure")).when((AsyncMultiStreamBlobContainer) blobContainer)
-            .asyncBlobUpload(any(WriteContext.class), any(ActionListener.class));
-
-        remoteRoutingTableService.start();
-        CheckedRunnable<IOException> runnable = remoteRoutingTableService.getIndexRoutingAsyncAction(
-            clusterState,
-            clusterState.routingTable().getIndicesRouting().get(indexName),
-            listener,
-            basePath
-        );
-        assertNotNull(runnable);
-        runnable.run();
-        verify(listener, times(1)).onFailure(any(RemoteStateTransferException.class));
-    }
-
     public void testGetAllUploadedIndicesRouting() {
         final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder().build();
         final ClusterMetadataManifest.UploadedIndexMetadata uploadedIndexMetadata = new ClusterMetadataManifest.UploadedIndexMetadata(
             "test-index",
             "index-uuid",
             "index-filename",
-            InternalRemoteRoutingTableService.INDEX_ROUTING_METADATA_PREFIX
+            INDEX_ROUTING_METADATA_PREFIX
         );
 
         List<ClusterMetadataManifest.UploadedIndexMetadata> allIndiceRoutingMetadata = remoteRoutingTableService
@@ -491,7 +393,7 @@ public void testGetAllUploadedIndicesRoutingExistingIndexInManifest() {
             "test-index",
             "index-uuid",
             "index-filename",
-            InternalRemoteRoutingTableService.INDEX_ROUTING_METADATA_PREFIX
+            INDEX_ROUTING_METADATA_PREFIX
         );
         final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
             .indicesRouting(List.of(uploadedIndexMetadata))
@@ -509,7 +411,7 @@ public void testGetAllUploadedIndicesRoutingNewIndexFromManifest() {
             "test-index",
             "index-uuid",
             "index-filename",
-            InternalRemoteRoutingTableService.INDEX_ROUTING_METADATA_PREFIX
+            INDEX_ROUTING_METADATA_PREFIX
         );
         final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
             .indicesRouting(List.of(uploadedIndexMetadata))
@@ -518,7 +420,7 @@ public void testGetAllUploadedIndicesRoutingNewIndexFromManifest() {
             "test-index2",
             "index-uuid",
             "index-filename",
-            InternalRemoteRoutingTableService.INDEX_ROUTING_METADATA_PREFIX
+            INDEX_ROUTING_METADATA_PREFIX
         );
 
         List<ClusterMetadataManifest.UploadedIndexMetadata> allIndiceRoutingMetadata = remoteRoutingTableService
@@ -534,13 +436,13 @@ public void testGetAllUploadedIndicesRoutingIndexDeleted() {
             "test-index",
             "index-uuid",
             "index-filename",
-            InternalRemoteRoutingTableService.INDEX_ROUTING_METADATA_PREFIX
+            INDEX_ROUTING_METADATA_PREFIX
         );
         final ClusterMetadataManifest.UploadedIndexMetadata uploadedIndexMetadata2 = new ClusterMetadataManifest.UploadedIndexMetadata(
             "test-index2",
             "index-uuid",
             "index-filename",
-            InternalRemoteRoutingTableService.INDEX_ROUTING_METADATA_PREFIX
+            INDEX_ROUTING_METADATA_PREFIX
         );
         final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
             .indicesRouting(List.of(uploadedIndexMetadata, uploadedIndexMetadata2))
@@ -558,13 +460,13 @@ public void testGetAllUploadedIndicesRoutingNoChange() {
             "test-index",
             "index-uuid",
             "index-filename",
-            InternalRemoteRoutingTableService.INDEX_ROUTING_METADATA_PREFIX
+            INDEX_ROUTING_METADATA_PREFIX
         );
         final ClusterMetadataManifest.UploadedIndexMetadata uploadedIndexMetadata2 = new ClusterMetadataManifest.UploadedIndexMetadata(
             "test-index2",
             "index-uuid",
             "index-filename",
-            InternalRemoteRoutingTableService.INDEX_ROUTING_METADATA_PREFIX
+            INDEX_ROUTING_METADATA_PREFIX
         );
         final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
             .indicesRouting(List.of(uploadedIndexMetadata, uploadedIndexMetadata2))
@@ -640,69 +542,183 @@ public void testIndicesRoutingDiffWhenIndexDeletedAndAdded() {
         );
     }
 
-    public void testGetAsyncIndexMetadataReadAction() throws Exception {
+    public void testGetAsyncIndexRoutingReadAction() throws Exception {
         String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
         ClusterState clusterState = createClusterState(indexName);
         String uploadedFileName = String.format(Locale.ROOT, "index-routing/" + indexName);
-        Index index = new Index(indexName, "uuid-01");
-
-        LatchedActionListener<IndexRoutingTable> listener = mock(LatchedActionListener.class);
-        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
-        BytesStreamOutput streamOutput = new BytesStreamOutput();
-        RemoteIndexRoutingTable remoteIndexRoutingTable = new RemoteIndexRoutingTable(
-            clusterState.routingTable().getIndicesRouting().get(indexName)
+        when(blobContainer.readBlob(indexName)).thenReturn(
+            INDEX_ROUTING_TABLE_FORMAT.serialize(
+                clusterState.getRoutingTable().getIndicesRouting().get(indexName),
+                uploadedFileName,
+                compressor
+            ).streamInput()
         );
-        remoteIndexRoutingTable.writeTo(streamOutput);
-        when(blobContainer.readBlob(indexName)).thenReturn(streamOutput.bytes().streamInput());
-        remoteRoutingTableService.start();
+        TestCapturingListener<IndexRoutingTable> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
 
-        CheckedRunnable<IOException> runnable = remoteRoutingTableService.getAsyncIndexRoutingReadAction(uploadedFileName, index, listener);
-        assertNotNull(runnable);
-        runnable.run();
+        remoteRoutingTableService.getAsyncIndexRoutingReadAction(
+            "cluster-uuid",
+            uploadedFileName,
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
 
-        assertBusy(() -> verify(blobContainer, times(1)).readBlob(any()));
-        assertBusy(() -> verify(listener, times(1)).onResponse(any(IndexRoutingTable.class)));
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        IndexRoutingTable indexRoutingTable = listener.getResult();
+        assertEquals(clusterState.getRoutingTable().getIndicesRouting().get(indexName), indexRoutingTable);
     }
 
-    public void testGetAsyncIndexMetadataReadActionFailureForIncorrectIndex() throws Exception {
+    public void testGetAsyncIndexRoutingTableDiffReadAction() throws Exception {
         String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
-        ClusterState clusterState = createClusterState(indexName);
-        String uploadedFileName = String.format(Locale.ROOT, "index-routing/" + indexName);
-        Index index = new Index("incorrect-index", "uuid-01");
+        ClusterState currentState = createClusterState(indexName);
 
-        LatchedActionListener<IndexRoutingTable> listener = mock(LatchedActionListener.class);
-        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
-        BytesStreamOutput streamOutput = new BytesStreamOutput();
-        RemoteIndexRoutingTable remoteIndexRoutingTable = new RemoteIndexRoutingTable(
-            clusterState.routingTable().getIndicesRouting().get(indexName)
+        // Get the IndexRoutingTable from the current state
+        IndexRoutingTable indexRoutingTable = currentState.routingTable().index(indexName);
+        Map<Integer, IndexShardRoutingTable> shardRoutingTables = indexRoutingTable.getShards();
+
+        RoutingTableIncrementalDiff.IndexRoutingTableIncrementalDiff indexRoutingTableDiff =
+            new RoutingTableIncrementalDiff.IndexRoutingTableIncrementalDiff(new ArrayList<>(shardRoutingTables.values()));
+
+        // Create the map for RoutingTableIncrementalDiff
+        Map<String, Diff<IndexRoutingTable>> diffs = new HashMap<>();
+        diffs.put(indexName, indexRoutingTableDiff);
+
+        RoutingTableIncrementalDiff diff = new RoutingTableIncrementalDiff(diffs);
+
+        String uploadedFileName = String.format(Locale.ROOT, "routing-table-diff/" + indexName);
+        when(blobContainer.readBlob(indexName)).thenReturn(
+            REMOTE_ROUTING_TABLE_DIFF_FORMAT.serialize(diff, uploadedFileName, compressor).streamInput()
         );
-        remoteIndexRoutingTable.writeTo(streamOutput);
-        when(blobContainer.readBlob(anyString())).thenReturn(streamOutput.bytes().streamInput());
-        remoteRoutingTableService.doStart();
 
-        CheckedRunnable<IOException> runnable = remoteRoutingTableService.getAsyncIndexRoutingReadAction(uploadedFileName, index, listener);
-        assertNotNull(runnable);
-        runnable.run();
+        TestCapturingListener<RoutingTableIncrementalDiff> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
 
-        assertBusy(() -> verify(blobContainer, times(1)).readBlob(any()));
-        assertBusy(() -> verify(listener, times(1)).onFailure(any(Exception.class)));
+        remoteRoutingTableService.getAsyncIndexRoutingTableDiffReadAction(
+            "cluster-uuid",
+            uploadedFileName,
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        RoutingTableIncrementalDiff resultDiff = listener.getResult();
+        assertEquals(diff.getDiffs().size(), resultDiff.getDiffs().size());
     }
 
-    public void testGetAsyncIndexMetadataReadActionFailureInBlobRepo() throws Exception {
+    public void testGetAsyncIndexRoutingWriteAction() throws Exception {
         String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
-        String uploadedFileName = String.format(Locale.ROOT, "index-routing/" + indexName);
-        Index index = new Index(indexName, "uuid-01");
+        ClusterState clusterState = createClusterState(indexName);
+        Iterable<String> remotePath = HASHED_PREFIX.path(
+            RemoteStorePathStrategy.PathInput.builder()
+                .basePath(
+                    new BlobPath().add("base-path")
+                        .add(RemoteClusterStateUtils.encodeString(ClusterName.DEFAULT.toString()))
+                        .add(CLUSTER_STATE_PATH_TOKEN)
+                        .add(clusterState.metadata().clusterUUID())
+                        .add(INDEX_ROUTING_TABLE)
+                )
+                .indexUUID(clusterState.getRoutingTable().indicesRouting().get(indexName).getIndex().getUUID())
+                .build(),
+            FNV_1A_BASE64
+        );
 
-        LatchedActionListener<IndexRoutingTable> listener = mock(LatchedActionListener.class);
-        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
-        doThrow(new IOException("testing failure")).when(blobContainer).readBlob(indexName);
-        remoteRoutingTableService.doStart();
+        doAnswer(invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onResponse(null);
+            return null;
+        }).when(blobStoreTransferService)
+            .uploadBlob(any(InputStream.class), eq(remotePath), anyString(), eq(WritePriority.URGENT), any(ActionListener.class));
+
+        TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        remoteRoutingTableService.getAsyncIndexRoutingWriteAction(
+            clusterState.metadata().clusterUUID(),
+            clusterState.term(),
+            clusterState.version(),
+            clusterState.getRoutingTable().indicesRouting().get(indexName),
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadata = listener.getResult();
+
+        assertEquals(INDEX_ROUTING_METADATA_PREFIX + indexName, uploadedMetadata.getComponent());
+        String uploadedFileName = uploadedMetadata.getUploadedFilename();
+        String[] pathTokens = uploadedFileName.split(PATH_DELIMITER);
+        assertEquals(8, pathTokens.length);
+        assertEquals(pathTokens[1], "base-path");
+        String[] fileNameTokens = pathTokens[7].split(DELIMITER);
+
+        assertEquals(4, fileNameTokens.length);
+        assertEquals(fileNameTokens[0], INDEX_ROUTING_FILE);
+        assertEquals(fileNameTokens[1], RemoteStoreUtils.invertLong(1L));
+        assertEquals(fileNameTokens[2], RemoteStoreUtils.invertLong(2L));
+        assertThat(RemoteStoreUtils.invertLong(fileNameTokens[3]), lessThanOrEqualTo(System.currentTimeMillis()));
+    }
+
+    public void testGetAsyncIndexRoutingDiffWriteAction() throws Exception {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        ClusterState currentState = createClusterState(indexName);
+
+        // Get the IndexRoutingTable from the current state
+        IndexRoutingTable indexRoutingTable = currentState.routingTable().index(indexName);
+        Map<Integer, IndexShardRoutingTable> shardRoutingTables = indexRoutingTable.getShards();
+
+        RoutingTableIncrementalDiff.IndexRoutingTableIncrementalDiff indexRoutingTableDiff =
+            new RoutingTableIncrementalDiff.IndexRoutingTableIncrementalDiff(new ArrayList<>(shardRoutingTables.values()));
+
+        // Create the map for RoutingTableIncrementalDiff
+        Map<String, Diff<IndexRoutingTable>> diffs = new HashMap<>();
+        diffs.put(indexName, indexRoutingTableDiff);
+
+        // RoutingTableIncrementalDiff diff = new RoutingTableIncrementalDiff(diffs);
 
-        CheckedRunnable<IOException> runnable = remoteRoutingTableService.getAsyncIndexRoutingReadAction(uploadedFileName, index, listener);
-        assertNotNull(runnable);
-        runnable.run();
+        Iterable<String> remotePath = new BlobPath().add("base-path")
+            .add(
+                Base64.getUrlEncoder()
+                    .withoutPadding()
+                    .encodeToString(currentState.getClusterName().value().getBytes(StandardCharsets.UTF_8))
+            )
+            .add("cluster-state")
+            .add(currentState.metadata().clusterUUID())
+            .add(ROUTING_TABLE_DIFF_PATH_TOKEN);
+
+        doAnswer(invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onResponse(null);
+            return null;
+        }).when(blobStoreTransferService)
+            .uploadBlob(any(InputStream.class), eq(remotePath), anyString(), eq(WritePriority.URGENT), any(ActionListener.class));
+
+        TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        remoteRoutingTableService.getAsyncIndexRoutingDiffWriteAction(
+            currentState.metadata().clusterUUID(),
+            currentState.term(),
+            currentState.version(),
+            diffs,
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadata = listener.getResult();
+
+        assertEquals(ROUTING_TABLE_DIFF_FILE, uploadedMetadata.getComponent());
+        String uploadedFileName = uploadedMetadata.getUploadedFilename();
+        String[] pathTokens = uploadedFileName.split(PATH_DELIMITER);
+        assertEquals(6, pathTokens.length);
+        assertEquals(pathTokens[0], "base-path");
+        String[] fileNameTokens = pathTokens[5].split(DELIMITER);
 
-        assertBusy(() -> verify(listener, times(1)).onFailure(any(RemoteStateTransferException.class)));
+        assertEquals(4, fileNameTokens.length);
+        assertEquals(ROUTING_TABLE_DIFF_METADATA_PREFIX, fileNameTokens[0]);
+        assertEquals(RemoteStoreUtils.invertLong(1L), fileNameTokens[1]);
+        assertEquals(RemoteStoreUtils.invertLong(2L), fileNameTokens[2]);
+        assertThat(RemoteStoreUtils.invertLong(fileNameTokens[3]), lessThanOrEqualTo(System.currentTimeMillis()));
     }
 
     public void testGetUpdatedIndexRoutingTableMetadataWhenNoChange() {
@@ -758,7 +774,7 @@ private ClusterState createClusterState(String indexName) {
     }
 
     private BlobPath getPath() {
-        BlobPath indexRoutingPath = basePath.add(INDEX_ROUTING_PATH_TOKEN);
+        BlobPath indexRoutingPath = basePath.add(INDEX_ROUTING_TABLE);
         return RemoteStoreEnums.PathType.HASHED_PREFIX.path(
             RemoteStorePathStrategy.PathInput.builder().basePath(indexRoutingPath).indexUUID("uuid").build(),
             RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64
@@ -788,4 +804,26 @@ public void testDeleteStaleIndexRoutingPathsThrowsIOException() throws IOExcepti
         verify(blobContainer).deleteBlobsIgnoringIfNotExists(stalePaths);
     }
 
+    public void testDeleteStaleIndexRoutingDiffPaths() throws IOException {
+        doNothing().when(blobContainer).deleteBlobsIgnoringIfNotExists(any());
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+        List<String> stalePaths = Arrays.asList("path1", "path2");
+        remoteRoutingTableService.doStart();
+        remoteRoutingTableService.deleteStaleIndexRoutingDiffPaths(stalePaths);
+        verify(blobContainer).deleteBlobsIgnoringIfNotExists(stalePaths);
+    }
+
+    public void testDeleteStaleIndexRoutingDiffPathsThrowsIOException() throws IOException {
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+        List<String> stalePaths = Arrays.asList("path1", "path2");
+        // Simulate an IOException
+        doThrow(new IOException("test exception")).when(blobContainer).deleteBlobsIgnoringIfNotExists(Mockito.anyList());
+
+        remoteRoutingTableService.doStart();
+        IOException thrown = assertThrows(IOException.class, () -> {
+            remoteRoutingTableService.deleteStaleIndexRoutingDiffPaths(stalePaths);
+        });
+        assertEquals("test exception", thrown.getMessage());
+        verify(blobContainer).deleteBlobsIgnoringIfNotExists(stalePaths);
+    }
 }
diff --git a/server/src/test/java/org/opensearch/cluster/service/MasterServiceTests.java b/server/src/test/java/org/opensearch/cluster/service/MasterServiceTests.java
index 55dab5e71e3d8..6a464f56b0669 100644
--- a/server/src/test/java/org/opensearch/cluster/service/MasterServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/service/MasterServiceTests.java
@@ -380,13 +380,13 @@ public void onFailure(String source, Exception e) {}
     }
 
     @TestLogging(value = "org.opensearch.cluster.service:TRACE", reason = "to ensure that we log cluster state events on TRACE level")
-    public void testClusterStateUpdateLogging() throws Exception {
+    public void testClusterStateUpdateLoggingWithTraceEnabled() throws Exception {
         try (MockLogAppender mockAppender = MockLogAppender.createForLoggers(LogManager.getLogger(MasterService.class))) {
             mockAppender.addExpectation(
                 new MockLogAppender.SeenEventExpectation(
                     "test1 start",
                     MasterService.class.getCanonicalName(),
-                    Level.DEBUG,
+                    Level.TRACE,
                     "executing cluster state update for [test1]"
                 )
             );
@@ -395,7 +395,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                     "test1 computation",
                     MasterService.class.getCanonicalName(),
                     Level.DEBUG,
-                    "took [1s] to compute cluster state update for [test1]"
+                    "took [1s] to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
             mockAppender.addExpectation(
@@ -403,7 +403,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                     "test1 notification",
                     MasterService.class.getCanonicalName(),
                     Level.DEBUG,
-                    "took [0s] to notify listeners on unchanged cluster state for [test1]"
+                    "took [0s] to notify listeners on unchanged cluster state for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
 
@@ -411,7 +411,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                 new MockLogAppender.SeenEventExpectation(
                     "test2 start",
                     MasterService.class.getCanonicalName(),
-                    Level.DEBUG,
+                    Level.TRACE,
                     "executing cluster state update for [test2]"
                 )
             );
@@ -420,7 +420,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                     "test2 failure",
                     MasterService.class.getCanonicalName(),
                     Level.TRACE,
-                    "failed to execute cluster state update (on version: [*], uuid: [*]) for [test2]*"
+                    "failed to execute cluster state update (on version: [*], uuid: [*]) for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]*"
                 )
             );
             mockAppender.addExpectation(
@@ -428,7 +428,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                     "test2 computation",
                     MasterService.class.getCanonicalName(),
                     Level.DEBUG,
-                    "took [2s] to compute cluster state update for [test2]"
+                    "took [2s] to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
             mockAppender.addExpectation(
@@ -436,7 +436,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                     "test2 notification",
                     MasterService.class.getCanonicalName(),
                     Level.DEBUG,
-                    "took [0s] to notify listeners on unchanged cluster state for [test2]"
+                    "took [0s] to notify listeners on unchanged cluster state for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
 
@@ -444,7 +444,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                 new MockLogAppender.SeenEventExpectation(
                     "test3 start",
                     MasterService.class.getCanonicalName(),
-                    Level.DEBUG,
+                    Level.TRACE,
                     "executing cluster state update for [test3]"
                 )
             );
@@ -453,7 +453,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                     "test3 computation",
                     MasterService.class.getCanonicalName(),
                     Level.DEBUG,
-                    "took [3s] to compute cluster state update for [test3]"
+                    "took [3s] to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
             mockAppender.addExpectation(
@@ -461,7 +461,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                     "test3 notification",
                     MasterService.class.getCanonicalName(),
                     Level.DEBUG,
-                    "took [4s] to notify listeners on successful publication of cluster state (version: *, uuid: *) for [test3]"
+                    "took [4s] to notify listeners on successful publication of cluster state (version: *, uuid: *) for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
 
@@ -469,7 +469,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                 new MockLogAppender.SeenEventExpectation(
                     "test4",
                     MasterService.class.getCanonicalName(),
-                    Level.DEBUG,
+                    Level.TRACE,
                     "executing cluster state update for [test4]"
                 )
             );
@@ -544,6 +544,171 @@ public void onFailure(String source, Exception e) {
         }
     }
 
+    @TestLogging(value = "org.opensearch.cluster.service:DEBUG", reason = "to ensure that we log cluster state events on DEBUG level")
+    public void testClusterStateUpdateLoggingWithDebugEnabled() throws Exception {
+        try (MockLogAppender mockAppender = MockLogAppender.createForLoggers(LogManager.getLogger(MasterService.class))) {
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test1 start",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "executing cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test1 computation",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "took [1s] to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test1 notification",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "took [0s] to notify listeners on unchanged cluster state for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test2 start",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "executing cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+            mockAppender.addExpectation(
+                new MockLogAppender.UnseenEventExpectation(
+                    "test2 failure",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "failed to execute cluster state update (on version: [*], uuid: [*]) for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]*"
+                )
+            );
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test2 computation",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "took [2s] to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test2 notification",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "took [0s] to notify listeners on unchanged cluster state for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test3 start",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "executing cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test3 computation",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "took [3s] to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test3 notification",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "took [4s] to notify listeners on successful publication of cluster state (version: *, uuid: *) for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test4",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "executing cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+
+            try (ClusterManagerService clusterManagerService = createClusterManagerService(true)) {
+                clusterManagerService.submitStateUpdateTask("test1", new ClusterStateUpdateTask() {
+                    @Override
+                    public ClusterState execute(ClusterState currentState) {
+                        timeDiffInMillis += TimeValue.timeValueSeconds(1).millis();
+                        return currentState;
+                    }
+
+                    @Override
+                    public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {}
+
+                    @Override
+                    public void onFailure(String source, Exception e) {
+                        fail();
+                    }
+                });
+                clusterManagerService.submitStateUpdateTask("test2", new ClusterStateUpdateTask() {
+                    @Override
+                    public ClusterState execute(ClusterState currentState) {
+                        timeDiffInMillis += TimeValue.timeValueSeconds(2).millis();
+                        throw new IllegalArgumentException("Testing handling of exceptions in the cluster state task");
+                    }
+
+                    @Override
+                    public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {
+                        fail();
+                    }
+
+                    @Override
+                    public void onFailure(String source, Exception e) {}
+                });
+                clusterManagerService.submitStateUpdateTask("test3", new ClusterStateUpdateTask() {
+                    @Override
+                    public ClusterState execute(ClusterState currentState) {
+                        timeDiffInMillis += TimeValue.timeValueSeconds(3).millis();
+                        return ClusterState.builder(currentState).incrementVersion().build();
+                    }
+
+                    @Override
+                    public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {
+                        timeDiffInMillis += TimeValue.timeValueSeconds(4).millis();
+                    }
+
+                    @Override
+                    public void onFailure(String source, Exception e) {
+                        fail();
+                    }
+                });
+                clusterManagerService.submitStateUpdateTask("test4", new ClusterStateUpdateTask() {
+                    @Override
+                    public ClusterState execute(ClusterState currentState) {
+                        return currentState;
+                    }
+
+                    @Override
+                    public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {}
+
+                    @Override
+                    public void onFailure(String source, Exception e) {
+                        fail();
+                    }
+                });
+                assertBusy(mockAppender::assertAllExpectationsMatched);
+                // verify stats values after state is published
+                assertEquals(1, clusterManagerService.getClusterStateStats().getUpdateSuccess());
+                assertEquals(0, clusterManagerService.getClusterStateStats().getUpdateFailed());
+            }
+        }
+    }
+
     public void testClusterStateBatchedUpdates() throws BrokenBarrierException, InterruptedException {
         AtomicInteger counter = new AtomicInteger();
         class Task {
@@ -1077,7 +1242,7 @@ public void testLongClusterStateUpdateLogging() throws Exception {
                     "test2",
                     MasterService.class.getCanonicalName(),
                     Level.WARN,
-                    "*took [*], which is over [10s], to compute cluster state update for [test2]"
+                    "*took [*], which is over [10s], to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
             mockAppender.addExpectation(
@@ -1085,7 +1250,7 @@ public void testLongClusterStateUpdateLogging() throws Exception {
                     "test3",
                     MasterService.class.getCanonicalName(),
                     Level.WARN,
-                    "*took [*], which is over [10s], to compute cluster state update for [test3]"
+                    "*took [*], which is over [10s], to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
             mockAppender.addExpectation(
@@ -1093,7 +1258,7 @@ public void testLongClusterStateUpdateLogging() throws Exception {
                     "test4",
                     MasterService.class.getCanonicalName(),
                     Level.WARN,
-                    "*took [*], which is over [10s], to compute cluster state update for [test4]"
+                    "*took [*], which is over [10s], to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
             mockAppender.addExpectation(
@@ -1104,14 +1269,6 @@ public void testLongClusterStateUpdateLogging() throws Exception {
                     "*took*test5*"
                 )
             );
-            mockAppender.addExpectation(
-                new MockLogAppender.SeenEventExpectation(
-                    "test6 should log due to slow and failing publication",
-                    MasterService.class.getCanonicalName(),
-                    Level.WARN,
-                    "took [*] and then failed to publish updated cluster state (version: *, uuid: *) for [test6]:*"
-                )
-            );
 
             try (
                 ClusterManagerService clusterManagerService = new ClusterManagerService(
@@ -1143,19 +1300,13 @@ public void testLongClusterStateUpdateLogging() throws Exception {
                             Settings.EMPTY
                         ).millis() + randomLongBetween(1, 1000000);
                     }
-                    if (event.source().contains("test6")) {
-                        timeDiffInMillis += ClusterManagerService.CLUSTER_MANAGER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING.get(
-                            Settings.EMPTY
-                        ).millis() + randomLongBetween(1, 1000000);
-                        throw new OpenSearchException("simulated error during slow publication which should trigger logging");
-                    }
                     clusterStateRef.set(event.state());
                     publishListener.onResponse(null);
                 });
                 clusterManagerService.setClusterStateSupplier(clusterStateRef::get);
                 clusterManagerService.start();
 
-                final CountDownLatch latch = new CountDownLatch(6);
+                final CountDownLatch latch = new CountDownLatch(5);
                 final CountDownLatch processedFirstTask = new CountDownLatch(1);
                 clusterManagerService.submitStateUpdateTask("test1", new ClusterStateUpdateTask() {
                     @Override
@@ -1253,7 +1404,77 @@ public void onFailure(String source, Exception e) {
                         fail();
                     }
                 });
+                // Additional update task to make sure all previous logging made it to the loggerName
+                // We don't check logging for this on since there is no guarantee that it will occur before our check
                 clusterManagerService.submitStateUpdateTask("test6", new ClusterStateUpdateTask() {
+                    @Override
+                    public ClusterState execute(ClusterState currentState) {
+                        return currentState;
+                    }
+
+                    @Override
+                    public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {
+                        latch.countDown();
+                    }
+
+                    @Override
+                    public void onFailure(String source, Exception e) {
+                        fail();
+                    }
+                });
+                latch.await();
+            }
+            mockAppender.assertAllExpectationsMatched();
+        }
+    }
+
+    @TestLogging(value = "org.opensearch.cluster.service:WARN", reason = "to ensure that we log failed cluster state events on WARN level")
+    public void testLongClusterStateUpdateLoggingForFailedPublication() throws Exception {
+        try (MockLogAppender mockAppender = MockLogAppender.createForLoggers(LogManager.getLogger(MasterService.class))) {
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test1 should log due to slow and failing publication",
+                    MasterService.class.getCanonicalName(),
+                    Level.WARN,
+                    "took [*] and then failed to publish updated cluster state (version: *, uuid: *) for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]:*"
+                )
+            );
+
+            try (
+                ClusterManagerService clusterManagerService = new ClusterManagerService(
+                    Settings.builder()
+                        .put(ClusterName.CLUSTER_NAME_SETTING.getKey(), MasterServiceTests.class.getSimpleName())
+                        .put(Node.NODE_NAME_SETTING.getKey(), "test_node")
+                        .build(),
+                    new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
+                    threadPool,
+                    new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
+                )
+            ) {
+
+                final DiscoveryNode localNode = new DiscoveryNode(
+                    "node1",
+                    buildNewFakeTransportAddress(),
+                    emptyMap(),
+                    emptySet(),
+                    Version.CURRENT
+                );
+                final ClusterState initialClusterState = ClusterState.builder(new ClusterName(MasterServiceTests.class.getSimpleName()))
+                    .nodes(DiscoveryNodes.builder().add(localNode).localNodeId(localNode.getId()).masterNodeId(localNode.getId()))
+                    .blocks(ClusterBlocks.EMPTY_CLUSTER_BLOCK)
+                    .build();
+                final AtomicReference<ClusterState> clusterStateRef = new AtomicReference<>(initialClusterState);
+                clusterManagerService.setClusterStatePublisher((event, publishListener, ackListener) -> {
+                    timeDiffInMillis += ClusterManagerService.CLUSTER_MANAGER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING.get(
+                        Settings.EMPTY
+                    ).millis() + randomLongBetween(1, 1000000);
+                    throw new OpenSearchException("simulated error during slow publication which should trigger logging");
+                });
+                clusterManagerService.setClusterStateSupplier(clusterStateRef::get);
+                clusterManagerService.start();
+
+                final CountDownLatch latch = new CountDownLatch(1);
+                clusterManagerService.submitStateUpdateTask("test1", new ClusterStateUpdateTask() {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         return ClusterState.builder(currentState).incrementVersion().build();
@@ -1266,12 +1487,12 @@ public void clusterStateProcessed(String source, ClusterState oldState, ClusterS
 
                     @Override
                     public void onFailure(String source, Exception e) {
-                        fail(); // maybe we should notify here?
+                        fail();
                     }
                 });
                 // Additional update task to make sure all previous logging made it to the loggerName
                 // We don't check logging for this on since there is no guarantee that it will occur before our check
-                clusterManagerService.submitStateUpdateTask("test7", new ClusterStateUpdateTask() {
+                clusterManagerService.submitStateUpdateTask("test2", new ClusterStateUpdateTask() {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         return currentState;
diff --git a/server/src/test/java/org/opensearch/cluster/service/TaskBatcherTests.java b/server/src/test/java/org/opensearch/cluster/service/TaskBatcherTests.java
index b0916ce9236f7..0ebcb51b557ae 100644
--- a/server/src/test/java/org/opensearch/cluster/service/TaskBatcherTests.java
+++ b/server/src/test/java/org/opensearch/cluster/service/TaskBatcherTests.java
@@ -55,6 +55,7 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.CyclicBarrier;
 import java.util.concurrent.Semaphore;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import static org.hamcrest.Matchers.containsString;
@@ -78,7 +79,7 @@ static class TestTaskBatcher extends TaskBatcher {
         }
 
         @Override
-        protected void run(Object batchingKey, List<? extends BatchedTask> tasks, String tasksSummary) {
+        protected void run(Object batchingKey, List<? extends BatchedTask> tasks, Function<Boolean, String> taskSummaryGenerator) {
             List<UpdateTask> updateTasks = (List) tasks;
             ((TestExecutor) batchingKey).execute(updateTasks.stream().map(t -> t.task).collect(Collectors.toList()));
             updateTasks.forEach(updateTask -> updateTask.listener.processed(updateTask.source));
diff --git a/server/src/test/java/org/opensearch/common/remote/AbstractRemoteWritableEntityManagerTests.java b/server/src/test/java/org/opensearch/common/remote/AbstractRemoteWritableEntityManagerTests.java
new file mode 100644
index 0000000000000..3d10bbf59f6ad
--- /dev/null
+++ b/server/src/test/java/org/opensearch/common/remote/AbstractRemoteWritableEntityManagerTests.java
@@ -0,0 +1,64 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.remote;
+
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.model.RemoteReadResult;
+import org.opensearch.test.OpenSearchTestCase;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class AbstractRemoteWritableEntityManagerTests extends OpenSearchTestCase {
+    public void testGetStoreWithKnownEntityType() {
+        AbstractRemoteWritableEntityManager manager = new ConcreteRemoteWritableEntityManager();
+        String knownEntityType = "knownType";
+        RemoteWritableEntityStore mockStore = mock(RemoteWritableEntityStore.class);
+        manager.remoteWritableEntityStores.put(knownEntityType, mockStore);
+        AbstractRemoteWritableBlobEntity mockEntity = mock(AbstractRemoteWritableBlobEntity.class);
+        when(mockEntity.getType()).thenReturn(knownEntityType);
+
+        RemoteWritableEntityStore store = manager.getStore(mockEntity);
+        verify(mockEntity).getType();
+        assertEquals(mockStore, store);
+    }
+
+    public void testGetStoreWithUnknownEntityType() {
+        AbstractRemoteWritableEntityManager manager = new ConcreteRemoteWritableEntityManager();
+        String unknownEntityType = "unknownType";
+        AbstractRemoteWritableBlobEntity mockEntity = mock(AbstractRemoteWritableBlobEntity.class);
+        when(mockEntity.getType()).thenReturn(unknownEntityType);
+
+        assertThrows(IllegalArgumentException.class, () -> manager.getStore(mockEntity));
+        verify(mockEntity, times(2)).getType();
+    }
+
+    private static class ConcreteRemoteWritableEntityManager extends AbstractRemoteWritableEntityManager {
+        @Override
+        protected ActionListener<Void> getWrappedWriteListener(
+            String component,
+            AbstractRemoteWritableBlobEntity remoteEntity,
+            ActionListener<ClusterMetadataManifest.UploadedMetadata> listener
+        ) {
+            return null;
+        }
+
+        @Override
+        protected ActionListener<Object> getWrappedReadListener(
+            String component,
+            AbstractRemoteWritableBlobEntity remoteEntity,
+            ActionListener<RemoteReadResult> listener
+        ) {
+            return null;
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/ReplicaShardBatchAllocatorTests.java b/server/src/test/java/org/opensearch/gateway/ReplicaShardBatchAllocatorTests.java
index 2e148c2bc8130..526a3990955b8 100644
--- a/server/src/test/java/org/opensearch/gateway/ReplicaShardBatchAllocatorTests.java
+++ b/server/src/test/java/org/opensearch/gateway/ReplicaShardBatchAllocatorTests.java
@@ -644,6 +644,25 @@ public void testDoNotCancelForBrokenNode() {
         assertThat(allocation.routingNodes().shardsWithState(ShardRoutingState.UNASSIGNED), empty());
     }
 
+    public void testDoNotCancelForInactivePrimaryNode() {
+        RoutingAllocation allocation = oneInactivePrimaryOnNode1And1ReplicaRecovering(yesAllocationDeciders(), null);
+        testBatchAllocator.addData(
+            node1,
+            null,
+            "MATCH",
+            null,
+            new StoreFileMetadata("file1", 10, "MATCH_CHECKSUM", MIN_SUPPORTED_LUCENE_VERSION)
+        ).addData(node2, randomSyncId(), null, new StoreFileMetadata("file1", 10, "MATCH_CHECKSUM", MIN_SUPPORTED_LUCENE_VERSION));
+
+        testBatchAllocator.processExistingRecoveries(
+            allocation,
+            Collections.singletonList(new ArrayList<>(allocation.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING)))
+        );
+
+        assertThat(allocation.routingNodesChanged(), equalTo(false));
+        assertThat(allocation.routingNodes().shardsWithState(ShardRoutingState.UNASSIGNED), empty());
+    }
+
     public void testAllocateUnassignedBatchThrottlingAllocationDeciderIsHonoured() throws InterruptedException {
         ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
         AllocationDeciders allocationDeciders = randomAllocationDeciders(
@@ -872,6 +891,41 @@ private RoutingAllocation onePrimaryOnNode1And1ReplicaRecovering(AllocationDecid
         );
     }
 
+    private RoutingAllocation oneInactivePrimaryOnNode1And1ReplicaRecovering(AllocationDeciders deciders, UnassignedInfo unassignedInfo) {
+        ShardRouting primaryShard = TestShardRouting.newShardRouting(shardId, node1.getId(), true, ShardRoutingState.INITIALIZING);
+        RoutingTable routingTable = RoutingTable.builder()
+            .add(
+                IndexRoutingTable.builder(shardId.getIndex())
+                    .addIndexShard(
+                        new IndexShardRoutingTable.Builder(shardId).addShard(primaryShard)
+                            .addShard(
+                                TestShardRouting.newShardRouting(
+                                    shardId,
+                                    node2.getId(),
+                                    null,
+                                    false,
+                                    ShardRoutingState.INITIALIZING,
+                                    unassignedInfo
+                                )
+                            )
+                            .build()
+                    )
+            )
+            .build();
+        ClusterState state = ClusterState.builder(org.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .routingTable(routingTable)
+            .nodes(DiscoveryNodes.builder().add(node1).add(node2))
+            .build();
+        return new RoutingAllocation(
+            deciders,
+            new RoutingNodes(state, false),
+            state,
+            ClusterInfo.EMPTY,
+            SnapshotShardSizeInfo.EMPTY,
+            System.nanoTime()
+        );
+    }
+
     private RoutingAllocation onePrimaryOnNode1And1ReplicaRecovering(AllocationDeciders deciders) {
         return onePrimaryOnNode1And1ReplicaRecovering(deciders, new UnassignedInfo(UnassignedInfo.Reason.CLUSTER_RECOVERED, null));
     }
diff --git a/server/src/test/java/org/opensearch/gateway/remote/ClusterMetadataManifestTests.java b/server/src/test/java/org/opensearch/gateway/remote/ClusterMetadataManifestTests.java
index 152a6dba6c032..8a6dd6bc96e72 100644
--- a/server/src/test/java/org/opensearch/gateway/remote/ClusterMetadataManifestTests.java
+++ b/server/src/test/java/org/opensearch/gateway/remote/ClusterMetadataManifestTests.java
@@ -10,10 +10,11 @@
 
 import org.opensearch.Version;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.DiffableUtils;
 import org.opensearch.cluster.metadata.IndexGraveyard;
 import org.opensearch.cluster.metadata.RepositoriesMetadata;
 import org.opensearch.cluster.metadata.WeightedRoutingMetadata;
-import org.opensearch.cluster.routing.remote.InternalRemoteRoutingTableService;
+import org.opensearch.cluster.routing.IndexRoutingTable;
 import org.opensearch.common.xcontent.json.JsonXContent;
 import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
@@ -30,9 +31,12 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import org.mockito.Mockito;
+
 import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V0;
 import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V1;
 import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.CLUSTER_BLOCKS;
@@ -44,6 +48,7 @@
 import static org.opensearch.gateway.remote.model.RemotePersistentSettingsMetadata.SETTING_METADATA;
 import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadata.TEMPLATES_METADATA;
 import static org.opensearch.gateway.remote.model.RemoteTransientSettingsMetadata.TRANSIENT_SETTING_METADATA;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_METADATA_PREFIX;
 
 public class ClusterMetadataManifestTests extends OpenSearchTestCase {
 
@@ -157,7 +162,7 @@ public void testClusterMetadataManifestSerializationEqualsHashCode() {
             .opensearchVersion(Version.CURRENT)
             .nodeId("B10RX1f5RJenMQvYccCgSQ")
             .committed(true)
-            .codecVersion(ClusterMetadataManifest.CODEC_V2)
+            .codecVersion(ClusterMetadataManifest.CODEC_V3)
             .indices(randomUploadedIndexMetadataList())
             .previousClusterUUID("yfObdx8KSMKKrXf8UyHhM")
             .clusterUUIDCommitted(true)
@@ -191,7 +196,9 @@ public void testClusterMetadataManifestSerializationEqualsHashCode() {
             .diffManifest(
                 new ClusterStateDiffManifest(
                     RemoteClusterStateServiceTests.generateClusterStateWithOneIndex().build(),
-                    ClusterState.EMPTY_STATE
+                    ClusterState.EMPTY_STATE,
+                    null,
+                    "indicesRoutingDiffPath"
                 )
             )
             .build();
@@ -523,7 +530,75 @@ public void testClusterMetadataManifestXContentV2() throws IOException {
             .diffManifest(
                 new ClusterStateDiffManifest(
                     RemoteClusterStateServiceTests.generateClusterStateWithOneIndex().build(),
-                    ClusterState.EMPTY_STATE
+                    ClusterState.EMPTY_STATE,
+                    null,
+                    null
+                )
+            )
+            .build();
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        originalManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final ClusterMetadataManifest fromXContentManifest = ClusterMetadataManifest.fromXContent(parser);
+            assertEquals(originalManifest, fromXContentManifest);
+        }
+    }
+
+    public void testClusterMetadataManifestXContentV3() throws IOException {
+        UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "test-uuid", "/test/upload/path");
+        UploadedMetadataAttribute uploadedMetadataAttribute = new UploadedMetadataAttribute("attribute_name", "testing_attribute");
+        final DiffableUtils.MapDiff<String, IndexRoutingTable, Map<String, IndexRoutingTable>> routingTableIncrementalDiff = Mockito.mock(
+            DiffableUtils.MapDiff.class
+        );
+        ClusterMetadataManifest originalManifest = ClusterMetadataManifest.builder()
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .clusterUUID("test-cluster-uuid")
+            .stateUUID("test-state-uuid")
+            .opensearchVersion(Version.CURRENT)
+            .nodeId("test-node-id")
+            .committed(false)
+            .codecVersion(ClusterMetadataManifest.CODEC_V3)
+            .indices(Collections.singletonList(uploadedIndexMetadata))
+            .previousClusterUUID("prev-cluster-uuid")
+            .clusterUUIDCommitted(true)
+            .coordinationMetadata(uploadedMetadataAttribute)
+            .settingMetadata(uploadedMetadataAttribute)
+            .templatesMetadata(uploadedMetadataAttribute)
+            .customMetadataMap(
+                Collections.unmodifiableList(
+                    Arrays.asList(
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + RepositoriesMetadata.TYPE,
+                            "custom--repositories-file"
+                        ),
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + IndexGraveyard.TYPE,
+                            "custom--index_graveyard-file"
+                        ),
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + WeightedRoutingMetadata.TYPE,
+                            "custom--weighted_routing_netadata-file"
+                        )
+                    )
+                ).stream().collect(Collectors.toMap(UploadedMetadataAttribute::getAttributeName, Function.identity()))
+            )
+            .routingTableVersion(1L)
+            .indicesRouting(Collections.singletonList(uploadedIndexMetadata))
+            .discoveryNodesMetadata(uploadedMetadataAttribute)
+            .clusterBlocksMetadata(uploadedMetadataAttribute)
+            .transientSettingsMetadata(uploadedMetadataAttribute)
+            .hashesOfConsistentSettings(uploadedMetadataAttribute)
+            .clusterStateCustomMetadataMap(Collections.emptyMap())
+            .diffManifest(
+                new ClusterStateDiffManifest(
+                    RemoteClusterStateServiceTests.generateClusterStateWithOneIndex().build(),
+                    ClusterState.EMPTY_STATE,
+                    routingTableIncrementalDiff,
+                    uploadedMetadataAttribute.getUploadedFilename()
                 )
             )
             .build();
@@ -545,7 +620,7 @@ public void testClusterMetadataManifestXContentV2WithoutEphemeral() throws IOExc
             "test-index",
             "test-uuid",
             "routing-path",
-            InternalRemoteRoutingTableService.INDEX_ROUTING_METADATA_PREFIX
+            INDEX_ROUTING_METADATA_PREFIX
         );
         ClusterMetadataManifest originalManifest = ClusterMetadataManifest.builder()
             .clusterTerm(1L)
diff --git a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateAttributesManagerTests.java b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateAttributesManagerTests.java
index 3f2edd1a6c5a5..4ef459e6657a1 100644
--- a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateAttributesManagerTests.java
+++ b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateAttributesManagerTests.java
@@ -107,7 +107,7 @@ public void tearDown() throws Exception {
         threadPool.shutdown();
     }
 
-    public void testGetAsyncMetadataWriteAction_DiscoveryNodes() throws IOException, InterruptedException {
+    public void testGetAsyncWriteRunnable_DiscoveryNodes() throws IOException, InterruptedException {
         DiscoveryNodes discoveryNodes = getDiscoveryNodes();
         RemoteDiscoveryNodes remoteDiscoveryNodes = new RemoteDiscoveryNodes(discoveryNodes, VERSION, CLUSTER_UUID, compressor);
         doAnswer(invocationOnMock -> {
@@ -117,11 +117,7 @@ public void testGetAsyncMetadataWriteAction_DiscoveryNodes() throws IOException,
             .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
         final CountDownLatch latch = new CountDownLatch(1);
         final TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
-        remoteClusterStateAttributesManager.getAsyncMetadataWriteAction(
-            DISCOVERY_NODES,
-            remoteDiscoveryNodes,
-            new LatchedActionListener<>(listener, latch)
-        ).run();
+        remoteClusterStateAttributesManager.writeAsync(DISCOVERY_NODES, remoteDiscoveryNodes, new LatchedActionListener<>(listener, latch));
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -140,7 +136,7 @@ public void testGetAsyncMetadataWriteAction_DiscoveryNodes() throws IOException,
         assertEquals(CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
     }
 
-    public void testGetAsyncMetadataReadAction_DiscoveryNodes() throws IOException, InterruptedException {
+    public void testGetAsyncReadRunnable_DiscoveryNodes() throws IOException, InterruptedException {
         DiscoveryNodes discoveryNodes = getDiscoveryNodes();
         String fileName = randomAlphaOfLength(10);
         when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenReturn(
@@ -149,11 +145,7 @@ public void testGetAsyncMetadataReadAction_DiscoveryNodes() throws IOException,
         RemoteDiscoveryNodes remoteObjForDownload = new RemoteDiscoveryNodes(fileName, "cluster-uuid", compressor);
         CountDownLatch latch = new CountDownLatch(1);
         TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
-        remoteClusterStateAttributesManager.getAsyncMetadataReadAction(
-            DISCOVERY_NODES,
-            remoteObjForDownload,
-            new LatchedActionListener<>(listener, latch)
-        ).run();
+        remoteClusterStateAttributesManager.readAsync(DISCOVERY_NODES, remoteObjForDownload, new LatchedActionListener<>(listener, latch));
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -165,7 +157,7 @@ public void testGetAsyncMetadataReadAction_DiscoveryNodes() throws IOException,
         assertEquals(discoveryNodes.getClusterManagerNodeId(), readDiscoveryNodes.getClusterManagerNodeId());
     }
 
-    public void testGetAsyncMetadataWriteAction_ClusterBlocks() throws IOException, InterruptedException {
+    public void testGetAsyncWriteRunnable_ClusterBlocks() throws IOException, InterruptedException {
         ClusterBlocks clusterBlocks = randomClusterBlocks();
         RemoteClusterBlocks remoteClusterBlocks = new RemoteClusterBlocks(clusterBlocks, VERSION, CLUSTER_UUID, compressor);
         doAnswer(invocationOnMock -> {
@@ -175,11 +167,7 @@ public void testGetAsyncMetadataWriteAction_ClusterBlocks() throws IOException,
             .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
         final CountDownLatch latch = new CountDownLatch(1);
         final TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
-        remoteClusterStateAttributesManager.getAsyncMetadataWriteAction(
-            CLUSTER_BLOCKS,
-            remoteClusterBlocks,
-            new LatchedActionListener<>(listener, latch)
-        ).run();
+        remoteClusterStateAttributesManager.writeAsync(CLUSTER_BLOCKS, remoteClusterBlocks, new LatchedActionListener<>(listener, latch));
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -198,7 +186,7 @@ public void testGetAsyncMetadataWriteAction_ClusterBlocks() throws IOException,
         assertEquals(CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
     }
 
-    public void testGetAsyncMetadataReadAction_ClusterBlocks() throws IOException, InterruptedException {
+    public void testGetAsyncReadRunnable_ClusterBlocks() throws IOException, InterruptedException {
         ClusterBlocks clusterBlocks = randomClusterBlocks();
         String fileName = randomAlphaOfLength(10);
         when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenReturn(
@@ -208,11 +196,7 @@ public void testGetAsyncMetadataReadAction_ClusterBlocks() throws IOException, I
         CountDownLatch latch = new CountDownLatch(1);
         TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
 
-        remoteClusterStateAttributesManager.getAsyncMetadataReadAction(
-            CLUSTER_BLOCKS,
-            remoteClusterBlocks,
-            new LatchedActionListener<>(listener, latch)
-        ).run();
+        remoteClusterStateAttributesManager.readAsync(CLUSTER_BLOCKS, remoteClusterBlocks, new LatchedActionListener<>(listener, latch));
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -226,7 +210,7 @@ public void testGetAsyncMetadataReadAction_ClusterBlocks() throws IOException, I
         }
     }
 
-    public void testGetAsyncMetadataWriteAction_Custom() throws IOException, InterruptedException {
+    public void testGetAsyncWriteRunnable_Custom() throws IOException, InterruptedException {
         Custom custom = getClusterStateCustom();
         RemoteClusterStateCustoms remoteClusterStateCustoms = new RemoteClusterStateCustoms(
             custom,
@@ -243,11 +227,11 @@ public void testGetAsyncMetadataWriteAction_Custom() throws IOException, Interru
             .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
         final TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
         final CountDownLatch latch = new CountDownLatch(1);
-        remoteClusterStateAttributesManager.getAsyncMetadataWriteAction(
+        remoteClusterStateAttributesManager.writeAsync(
             CLUSTER_STATE_CUSTOM,
             remoteClusterStateCustoms,
             new LatchedActionListener<>(listener, latch)
-        ).run();
+        );
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -266,7 +250,7 @@ public void testGetAsyncMetadataWriteAction_Custom() throws IOException, Interru
         assertEquals(CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
     }
 
-    public void testGetAsyncMetadataReadAction_Custom() throws IOException, InterruptedException {
+    public void testGetAsyncReadRunnable_Custom() throws IOException, InterruptedException {
         Custom custom = getClusterStateCustom();
         String fileName = randomAlphaOfLength(10);
         RemoteClusterStateCustoms remoteClusterStateCustoms = new RemoteClusterStateCustoms(
@@ -281,11 +265,11 @@ public void testGetAsyncMetadataReadAction_Custom() throws IOException, Interrup
         );
         TestCapturingListener<RemoteReadResult> capturingListener = new TestCapturingListener<>();
         final CountDownLatch latch = new CountDownLatch(1);
-        remoteClusterStateAttributesManager.getAsyncMetadataReadAction(
+        remoteClusterStateAttributesManager.readAsync(
             CLUSTER_STATE_CUSTOM,
             remoteClusterStateCustoms,
             new LatchedActionListener<>(capturingListener, latch)
-        ).run();
+        );
         latch.await();
         assertNull(capturingListener.getFailure());
         assertNotNull(capturingListener.getResult());
@@ -294,7 +278,7 @@ public void testGetAsyncMetadataReadAction_Custom() throws IOException, Interrup
         assertEquals(CLUSTER_STATE_CUSTOM, capturingListener.getResult().getComponentName());
     }
 
-    public void testGetAsyncMetadataWriteAction_Exception() throws IOException, InterruptedException {
+    public void testGetAsyncWriteRunnable_Exception() throws IOException, InterruptedException {
         DiscoveryNodes discoveryNodes = getDiscoveryNodes();
         RemoteDiscoveryNodes remoteDiscoveryNodes = new RemoteDiscoveryNodes(discoveryNodes, VERSION, CLUSTER_UUID, compressor);
 
@@ -307,32 +291,33 @@ public void testGetAsyncMetadataWriteAction_Exception() throws IOException, Inte
 
         TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> capturingListener = new TestCapturingListener<>();
         final CountDownLatch latch = new CountDownLatch(1);
-        remoteClusterStateAttributesManager.getAsyncMetadataWriteAction(
+        remoteClusterStateAttributesManager.writeAsync(
             DISCOVERY_NODES,
             remoteDiscoveryNodes,
             new LatchedActionListener<>(capturingListener, latch)
-        ).run();
+        );
         latch.await();
         assertNull(capturingListener.getResult());
         assertTrue(capturingListener.getFailure() instanceof RemoteStateTransferException);
         assertEquals(ioException, capturingListener.getFailure().getCause());
     }
 
-    public void testGetAsyncMetadataReadAction_Exception() throws IOException, InterruptedException {
+    public void testGetAsyncReadRunnable_Exception() throws IOException, InterruptedException {
         String fileName = randomAlphaOfLength(10);
         RemoteDiscoveryNodes remoteDiscoveryNodes = new RemoteDiscoveryNodes(fileName, CLUSTER_UUID, compressor);
         Exception ioException = new IOException("mock test exception");
         when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenThrow(ioException);
         CountDownLatch latch = new CountDownLatch(1);
         TestCapturingListener<RemoteReadResult> capturingListener = new TestCapturingListener<>();
-        remoteClusterStateAttributesManager.getAsyncMetadataReadAction(
+        remoteClusterStateAttributesManager.readAsync(
             DISCOVERY_NODES,
             remoteDiscoveryNodes,
             new LatchedActionListener<>(capturingListener, latch)
-        ).run();
+        );
         latch.await();
         assertNull(capturingListener.getResult());
-        assertEquals(ioException, capturingListener.getFailure());
+        assertEquals(ioException, capturingListener.getFailure().getCause());
+        assertTrue(capturingListener.getFailure() instanceof RemoteStateTransferException);
     }
 
     public void testGetUpdatedCustoms() {
diff --git a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerTests.java b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerTests.java
index ec7e3c1ce81d3..b86f23f3d37aa 100644
--- a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerTests.java
+++ b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerTests.java
@@ -50,6 +50,7 @@
 
 import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V1;
 import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V2;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V3;
 import static org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedIndexMetadata;
 import static org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
 import static org.opensearch.gateway.remote.RemoteClusterStateCleanupManager.AsyncStaleFileDeletion;
@@ -296,6 +297,74 @@ public void testDeleteClusterMetadata() throws IOException {
         verify(remoteRoutingTableService).deleteStaleIndexRoutingPaths(List.of(index3Metadata.getUploadedFilename()));
     }
 
+    public void testDeleteStaleIndicesRoutingDiffFile() throws IOException {
+        String clusterUUID = "clusterUUID";
+        String clusterName = "test-cluster";
+        List<BlobMetadata> inactiveBlobs = Arrays.asList(new PlainBlobMetadata("manifest1.dat", 1L));
+        List<BlobMetadata> activeBlobs = Arrays.asList(new PlainBlobMetadata("manifest2.dat", 1L));
+
+        UploadedMetadataAttribute coordinationMetadata = new UploadedMetadataAttribute(COORDINATION_METADATA, "coordination_metadata");
+        UploadedMetadataAttribute templateMetadata = new UploadedMetadataAttribute(TEMPLATES_METADATA, "template_metadata");
+        UploadedMetadataAttribute settingMetadata = new UploadedMetadataAttribute(SETTING_METADATA, "settings_metadata");
+        UploadedMetadataAttribute coordinationMetadataUpdated = new UploadedMetadataAttribute(
+            COORDINATION_METADATA,
+            "coordination_metadata_updated"
+        );
+
+        UploadedIndexMetadata index1Metadata = new UploadedIndexMetadata("index1", "indexUUID1", "index_metadata1__2");
+        UploadedIndexMetadata index2Metadata = new UploadedIndexMetadata("index2", "indexUUID2", "index_metadata2__2");
+        List<UploadedIndexMetadata> indicesRouting1 = List.of(index1Metadata);
+        List<UploadedIndexMetadata> indicesRouting2 = List.of(index2Metadata);
+        ClusterStateDiffManifest diffManifest1 = ClusterStateDiffManifest.builder().indicesRoutingDiffPath("index1RoutingDiffPath").build();
+        ClusterStateDiffManifest diffManifest2 = ClusterStateDiffManifest.builder().indicesRoutingDiffPath("index2RoutingDiffPath").build();
+
+        ClusterMetadataManifest manifest1 = ClusterMetadataManifest.builder()
+            .indices(List.of(index1Metadata))
+            .coordinationMetadata(coordinationMetadataUpdated)
+            .templatesMetadata(templateMetadata)
+            .settingMetadata(settingMetadata)
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .codecVersion(CODEC_V3)
+            .stateUUID(randomAlphaOfLength(10))
+            .clusterUUID(clusterUUID)
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .previousClusterUUID(ClusterState.UNKNOWN_UUID)
+            .committed(true)
+            .routingTableVersion(0L)
+            .indicesRouting(indicesRouting1)
+            .diffManifest(diffManifest1)
+            .build();
+        ClusterMetadataManifest manifest2 = ClusterMetadataManifest.builder(manifest1)
+            .indices(List.of(index2Metadata))
+            .indicesRouting(indicesRouting2)
+            .diffManifest(diffManifest2)
+            .build();
+
+        BlobContainer blobContainer = mock(BlobContainer.class);
+        doThrow(IOException.class).when(blobContainer).delete();
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+        BlobPath blobPath = new BlobPath().add("random-path");
+        when((blobStoreRepository.basePath())).thenReturn(blobPath);
+        remoteClusterStateCleanupManager.start();
+        when(remoteManifestManager.getManifestFolderPath(eq(clusterName), eq(clusterUUID))).thenReturn(
+            new BlobPath().add(encodeString(clusterName)).add(CLUSTER_STATE_PATH_TOKEN).add(clusterUUID).add(MANIFEST)
+        );
+        when(remoteManifestManager.fetchRemoteClusterMetadataManifest(eq(clusterName), eq(clusterUUID), any())).thenReturn(
+            manifest2,
+            manifest1
+        );
+        remoteClusterStateCleanupManager = new RemoteClusterStateCleanupManager(
+            remoteClusterStateService,
+            clusterService,
+            remoteRoutingTableService
+        );
+        remoteClusterStateCleanupManager.start();
+        remoteClusterStateCleanupManager.deleteClusterMetadata(clusterName, clusterUUID, activeBlobs, inactiveBlobs);
+        verify(remoteRoutingTableService).deleteStaleIndexRoutingDiffPaths(List.of("index1RoutingDiffPath"));
+    }
+
     public void testDeleteClusterMetadataNoOpsRoutingTableService() throws IOException {
         String clusterUUID = "clusterUUID";
         String clusterName = "test-cluster";
@@ -515,6 +584,83 @@ public void testIndexRoutingFilesCleanupFailureStats() throws Exception {
         });
     }
 
+    public void testIndicesRoutingDiffFilesCleanupFailureStats() throws Exception {
+        String clusterUUID = "clusterUUID";
+        String clusterName = "test-cluster";
+        List<BlobMetadata> inactiveBlobs = Arrays.asList(new PlainBlobMetadata("manifest1.dat", 1L));
+        List<BlobMetadata> activeBlobs = Arrays.asList(new PlainBlobMetadata("manifest2.dat", 1L));
+
+        UploadedMetadataAttribute coordinationMetadata = new UploadedMetadataAttribute(COORDINATION_METADATA, "coordination_metadata");
+        UploadedMetadataAttribute templateMetadata = new UploadedMetadataAttribute(TEMPLATES_METADATA, "template_metadata");
+        UploadedMetadataAttribute settingMetadata = new UploadedMetadataAttribute(SETTING_METADATA, "settings_metadata");
+        UploadedMetadataAttribute coordinationMetadataUpdated = new UploadedMetadataAttribute(
+            COORDINATION_METADATA,
+            "coordination_metadata_updated"
+        );
+
+        UploadedIndexMetadata index1Metadata = new UploadedIndexMetadata("index1", "indexUUID1", "index_metadata1__2");
+        UploadedIndexMetadata index2Metadata = new UploadedIndexMetadata("index2", "indexUUID2", "index_metadata2__2");
+        List<UploadedIndexMetadata> indicesRouting1 = List.of(index1Metadata);
+        List<UploadedIndexMetadata> indicesRouting2 = List.of(index2Metadata);
+        ClusterStateDiffManifest diffManifest1 = ClusterStateDiffManifest.builder().indicesRoutingDiffPath("index1RoutingDiffPath").build();
+        ClusterStateDiffManifest diffManifest2 = ClusterStateDiffManifest.builder().indicesRoutingDiffPath("index2RoutingDiffPath").build();
+
+        ClusterMetadataManifest manifest1 = ClusterMetadataManifest.builder()
+            .indices(List.of(index1Metadata))
+            .coordinationMetadata(coordinationMetadataUpdated)
+            .templatesMetadata(templateMetadata)
+            .settingMetadata(settingMetadata)
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .codecVersion(CODEC_V3)
+            .stateUUID(randomAlphaOfLength(10))
+            .clusterUUID(clusterUUID)
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .previousClusterUUID(ClusterState.UNKNOWN_UUID)
+            .committed(true)
+            .routingTableVersion(0L)
+            .indicesRouting(indicesRouting1)
+            .diffManifest(diffManifest1)
+            .build();
+        ClusterMetadataManifest manifest2 = ClusterMetadataManifest.builder(manifest1)
+            .indices(List.of(index2Metadata))
+            .indicesRouting(indicesRouting2)
+            .diffManifest(diffManifest2)
+            .build();
+
+        BlobContainer blobContainer = mock(BlobContainer.class);
+        doThrow(IOException.class).when(blobContainer).delete();
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+
+        BlobPath blobPath = new BlobPath().add("random-path");
+        when((blobStoreRepository.basePath())).thenReturn(blobPath);
+        remoteClusterStateCleanupManager.start();
+        when(remoteManifestManager.getManifestFolderPath(eq(clusterName), eq(clusterUUID))).thenReturn(
+            new BlobPath().add(encodeString(clusterName)).add(CLUSTER_STATE_PATH_TOKEN).add(clusterUUID).add(MANIFEST)
+        );
+        when(remoteManifestManager.fetchRemoteClusterMetadataManifest(eq(clusterName), eq(clusterUUID), any())).thenReturn(
+            manifest1,
+            manifest2
+        );
+        doNothing().when(remoteRoutingTableService).deleteStaleIndexRoutingDiffPaths(any());
+
+        remoteClusterStateCleanupManager.deleteClusterMetadata(clusterName, clusterUUID, activeBlobs, inactiveBlobs);
+        assertBusy(() -> {
+            // wait for stats to get updated
+            assertNotNull(remoteClusterStateCleanupManager.getStats());
+            assertEquals(0, remoteClusterStateCleanupManager.getStats().getIndicesRoutingDiffFileCleanupAttemptFailedCount());
+        });
+
+        doThrow(IOException.class).when(remoteRoutingTableService).deleteStaleIndexRoutingPaths(any());
+        remoteClusterStateCleanupManager.deleteClusterMetadata(clusterName, clusterUUID, activeBlobs, inactiveBlobs);
+        assertBusy(() -> {
+            // wait for stats to get updated
+            assertNotNull(remoteClusterStateCleanupManager.getStats());
+            assertEquals(1, remoteClusterStateCleanupManager.getStats().getIndicesRoutingDiffFileCleanupAttemptFailedCount());
+        });
+    }
+
     public void testSingleConcurrentExecutionOfStaleManifestCleanup() throws Exception {
         BlobContainer blobContainer = mock(BlobContainer.class);
         when(blobStore.blobContainer(any())).thenReturn(blobContainer);
diff --git a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java
index 6cd9cbbf13848..59ca62dff2aa7 100644
--- a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java
+++ b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java
@@ -117,16 +117,17 @@
 import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.TestClusterStateCustom1;
 import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.TestClusterStateCustom2;
 import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.TestClusterStateCustom3;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CUSTOM_DELIMITER;
 import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
 import static org.opensearch.gateway.remote.RemoteClusterStateUtils.FORMAT_PARAMS;
 import static org.opensearch.gateway.remote.RemoteClusterStateUtils.getFormattedIndexFileName;
+import static org.opensearch.gateway.remote.RemoteGlobalMetadataManager.GLOBAL_METADATA_UPLOAD_TIMEOUT_DEFAULT;
 import static org.opensearch.gateway.remote.model.RemoteClusterBlocks.CLUSTER_BLOCKS_FORMAT;
 import static org.opensearch.gateway.remote.model.RemoteClusterBlocksTests.randomClusterBlocks;
 import static org.opensearch.gateway.remote.model.RemoteClusterMetadataManifest.MANIFEST_CURRENT_CODEC_VERSION;
 import static org.opensearch.gateway.remote.model.RemoteClusterStateCustoms.CLUSTER_STATE_CUSTOM;
 import static org.opensearch.gateway.remote.model.RemoteCoordinationMetadata.COORDINATION_METADATA;
 import static org.opensearch.gateway.remote.model.RemoteCoordinationMetadata.COORDINATION_METADATA_FORMAT;
-import static org.opensearch.gateway.remote.model.RemoteCustomMetadata.CUSTOM_DELIMITER;
 import static org.opensearch.gateway.remote.model.RemoteCustomMetadata.CUSTOM_METADATA;
 import static org.opensearch.gateway.remote.model.RemoteCustomMetadata.readFrom;
 import static org.opensearch.gateway.remote.model.RemoteDiscoveryNodes.DISCOVERY_NODES;
@@ -144,6 +145,7 @@
 import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadata.TEMPLATES_METADATA_FORMAT;
 import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadataTests.getTemplatesMetadata;
 import static org.opensearch.gateway.remote.model.RemoteTransientSettingsMetadata.TRANSIENT_SETTING_METADATA;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_METADATA_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT;
@@ -533,14 +535,15 @@ public void testTimeoutWhileWritingManifestFile() throws IOException {
                 anyBoolean(),
                 anyMap(),
                 anyBoolean(),
-                anyList()
+                anyList(),
+                anyMap()
             )
         ).thenReturn(new RemoteClusterStateUtils.UploadedMetadataResults());
         RemoteStateTransferException ex = expectThrows(
             RemoteStateTransferException.class,
             () -> spiedService.writeFullMetadata(clusterState, randomAlphaOfLength(10))
         );
-        assertTrue(ex.getMessage().contains("Timed out waiting for transfer of manifest file to complete"));
+        assertTrue(ex.getMessage().contains("Timed out waiting for transfer of following metadata to complete"));
     }
 
     public void testWriteFullMetadataInParallelFailureForIndexMetadata() throws IOException {
@@ -589,6 +592,56 @@ public void testFailWriteIncrementalMetadataWhenTermChanged() {
         );
     }
 
+    public void testWriteMetadataInParallelIncompleteUpload() throws IOException {
+        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+        final RemoteClusterStateService rcssSpy = Mockito.spy(remoteClusterStateService);
+        rcssSpy.start();
+        RemoteIndexMetadataManager mockedIndexManager = mock(RemoteIndexMetadataManager.class);
+        RemoteGlobalMetadataManager mockedGlobalMetadataManager = mock(RemoteGlobalMetadataManager.class);
+        RemoteClusterStateAttributesManager mockedClusterStateAttributeManager = mock(RemoteClusterStateAttributesManager.class);
+        ClusterMetadataManifest.UploadedMetadata mockedUploadedMetadata = mock(ClusterMetadataManifest.UploadedMetadata.class);
+        rcssSpy.setRemoteIndexMetadataManager(mockedIndexManager);
+        rcssSpy.setRemoteGlobalMetadataManager(mockedGlobalMetadataManager);
+        rcssSpy.setRemoteClusterStateAttributesManager(mockedClusterStateAttributeManager);
+        ArgumentCaptor<LatchedActionListener> listenerArgumentCaptor = ArgumentCaptor.forClass(LatchedActionListener.class);
+
+        when(mockedGlobalMetadataManager.getGlobalMetadataUploadTimeout()).thenReturn(GLOBAL_METADATA_UPLOAD_TIMEOUT_DEFAULT);
+        when(mockedUploadedMetadata.getComponent()).thenReturn("test-component");
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedUploadedMetadata);
+            return null;
+        }).when(mockedIndexManager).writeAsync(any(), any(), listenerArgumentCaptor.capture());
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedUploadedMetadata);
+            return null;
+        }).when(mockedGlobalMetadataManager).writeAsync(anyString(), any(), listenerArgumentCaptor.capture());
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedUploadedMetadata);
+            return null;
+        }).when(mockedClusterStateAttributeManager).writeAsync(any(), any(), listenerArgumentCaptor.capture());
+
+        RemoteStateTransferException exception = expectThrows(
+            RemoteStateTransferException.class,
+            () -> rcssSpy.writeMetadataInParallel(
+                clusterState,
+                new ArrayList<>(clusterState.getMetadata().indices().values()),
+                emptyMap(),
+                clusterState.getMetadata().customs(),
+                true,
+                true,
+                true,
+                true,
+                true,
+                true,
+                clusterState.getCustoms(),
+                true,
+                emptyList(),
+                null
+            )
+        );
+        assertTrue(exception.getMessage().startsWith("Some metadata components were not uploaded successfully"));
+    }
+
     public void testWriteIncrementalMetadataSuccess() throws IOException {
         final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
         mockBlobStoreObjects();
@@ -633,7 +686,8 @@ public void testWriteIncrementalMetadataSuccess() throws IOException {
                 eq(false),
                 eq(Collections.emptyMap()),
                 eq(false),
-                eq(Collections.emptyList())
+                eq(Collections.emptyList()),
+                eq(Collections.emptyMap())
             );
 
         assertThat(manifestInfo.getManifestFileName(), notNullValue());
@@ -713,7 +767,8 @@ public void testWriteIncrementalMetadataSuccessWhenPublicationEnabled() throws I
                 eq(false),
                 eq(Collections.emptyMap()),
                 eq(true),
-                Mockito.anyList()
+                anyList(),
+                eq(Collections.emptyMap())
             );
 
         assertThat(manifestInfo.getManifestFileName(), notNullValue());
@@ -760,7 +815,8 @@ public void testTimeoutWhileWritingMetadata() throws IOException {
                 true,
                 emptyMap(),
                 true,
-                emptyList()
+                emptyList(),
+                null
             )
         );
         assertTrue(exception.getMessage().startsWith("Timed out waiting for transfer of following metadata to complete"));
@@ -780,14 +836,18 @@ public void testGetClusterStateForManifest_IncludeEphemeral() throws IOException
         ArgumentCaptor<LatchedActionListener<RemoteReadResult>> listenerArgumentCaptor = ArgumentCaptor.forClass(
             LatchedActionListener.class
         );
-        when(mockedIndexManager.getAsyncIndexMetadataReadAction(any(), anyString(), listenerArgumentCaptor.capture())).thenReturn(
-            () -> listenerArgumentCaptor.getValue().onResponse(mockedResult)
-        );
-        when(mockedGlobalMetadataManager.getAsyncMetadataReadAction(any(), anyString(), listenerArgumentCaptor.capture())).thenReturn(
-            () -> listenerArgumentCaptor.getValue().onResponse(mockedResult)
-        );
-        when(mockedClusterStateAttributeManager.getAsyncMetadataReadAction(anyString(), any(), listenerArgumentCaptor.capture()))
-            .thenReturn(() -> listenerArgumentCaptor.getValue().onResponse(mockedResult));
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedResult);
+            return null;
+        }).when(mockedIndexManager).readAsync(any(), any(), listenerArgumentCaptor.capture());
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedResult);
+            return null;
+        }).when(mockedGlobalMetadataManager).readAsync(any(), any(), listenerArgumentCaptor.capture());
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedResult);
+            return null;
+        }).when(mockedClusterStateAttributeManager).readAsync(anyString(), any(), listenerArgumentCaptor.capture());
         when(mockedResult.getComponent()).thenReturn(COORDINATION_METADATA);
         RemoteClusterStateService mockService = spy(remoteClusterStateService);
         mockService.getClusterStateForManifest(ClusterName.DEFAULT.value(), manifest, NODE_ID, true);
@@ -807,6 +867,7 @@ public void testGetClusterStateForManifest_IncludeEphemeral() throws IOException
             eq(manifest.getIndicesRouting()),
             eq(true),
             eq(manifest.getClusterStateCustomMap()),
+            eq(false),
             eq(true)
         );
     }
@@ -822,14 +883,18 @@ public void testGetClusterStateForManifest_ExcludeEphemeral() throws IOException
         ArgumentCaptor<LatchedActionListener<RemoteReadResult>> listenerArgumentCaptor = ArgumentCaptor.forClass(
             LatchedActionListener.class
         );
-        when(mockedIndexManager.getAsyncIndexMetadataReadAction(any(), anyString(), listenerArgumentCaptor.capture())).thenReturn(
-            () -> listenerArgumentCaptor.getValue().onResponse(mockedResult)
-        );
-        when(mockedGlobalMetadataManager.getAsyncMetadataReadAction(any(), anyString(), listenerArgumentCaptor.capture())).thenReturn(
-            () -> listenerArgumentCaptor.getValue().onResponse(mockedResult)
-        );
-        when(mockedClusterStateAttributeManager.getAsyncMetadataReadAction(anyString(), any(), listenerArgumentCaptor.capture()))
-            .thenReturn(() -> listenerArgumentCaptor.getValue().onResponse(mockedResult));
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedResult);
+            return null;
+        }).when(mockedIndexManager).readAsync(anyString(), any(), listenerArgumentCaptor.capture());
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedResult);
+            return null;
+        }).when(mockedGlobalMetadataManager).readAsync(anyString(), any(), listenerArgumentCaptor.capture());
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedResult);
+            return null;
+        }).when(mockedClusterStateAttributeManager).readAsync(anyString(), any(), listenerArgumentCaptor.capture());
         when(mockedResult.getComponent()).thenReturn(COORDINATION_METADATA);
         remoteClusterStateService.setRemoteIndexMetadataManager(mockedIndexManager);
         remoteClusterStateService.setRemoteGlobalMetadataManager(mockedGlobalMetadataManager);
@@ -852,7 +917,9 @@ public void testGetClusterStateForManifest_ExcludeEphemeral() throws IOException
             eq(emptyList()),
             eq(false),
             eq(emptyMap()),
+            eq(false),
             eq(false)
+
         );
     }
 
@@ -876,9 +943,10 @@ public void testGetClusterStateFromManifest_CodecV1() throws IOException {
         ArgumentCaptor<LatchedActionListener<RemoteReadResult>> listenerArgumentCaptor = ArgumentCaptor.forClass(
             LatchedActionListener.class
         );
-        when(mockedIndexManager.getAsyncIndexMetadataReadAction(any(), anyString(), listenerArgumentCaptor.capture())).thenReturn(
-            () -> listenerArgumentCaptor.getValue().onResponse(new RemoteReadResult(indexMetadata, INDEX, INDEX))
-        );
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(new RemoteReadResult(indexMetadata, INDEX, INDEX));
+            return null;
+        }).when(mockedIndexManager).readAsync(anyString(), any(), listenerArgumentCaptor.capture());
         when(mockedGlobalMetadataManager.getGlobalMetadata(anyString(), eq(manifest))).thenReturn(Metadata.EMPTY_METADATA);
         RemoteClusterStateService spiedService = spy(remoteClusterStateService);
         spiedService.getClusterStateForManifest(ClusterName.DEFAULT.value(), manifest, NODE_ID, true);
@@ -898,6 +966,7 @@ public void testGetClusterStateFromManifest_CodecV1() throws IOException {
             eq(emptyList()),
             eq(false),
             eq(emptyMap()),
+            eq(false),
             eq(false)
         );
         verify(mockedGlobalMetadataManager, times(1)).getGlobalMetadata(eq(manifest.getClusterUUID()), eq(manifest));
@@ -1221,6 +1290,7 @@ public void testReadClusterStateInParallel_TimedOut() throws IOException {
                 emptyList(),
                 true,
                 emptyMap(),
+                false,
                 true
             )
         );
@@ -1252,12 +1322,13 @@ public void testReadClusterStateInParallel_ExceptionDuringRead() throws IOExcept
                 emptyList(),
                 true,
                 emptyMap(),
+                false,
                 true
             )
         );
         assertEquals("Exception during reading cluster state from remote", exception.getMessage());
         assertTrue(exception.getSuppressed().length > 0);
-        assertEquals(mockException, exception.getSuppressed()[0]);
+        assertEquals(mockException, exception.getSuppressed()[0].getCause());
     }
 
     public void testReadClusterStateInParallel_UnexpectedResult() throws IOException {
@@ -1321,19 +1392,20 @@ public void testReadClusterStateInParallel_UnexpectedResult() throws IOException
         RemoteIndexMetadataManager mockIndexMetadataManager = mock(RemoteIndexMetadataManager.class);
         CheckedRunnable<IOException> mockRunnable = mock(CheckedRunnable.class);
         ArgumentCaptor<LatchedActionListener<RemoteReadResult>> latchCapture = ArgumentCaptor.forClass(LatchedActionListener.class);
-        when(mockIndexMetadataManager.getAsyncIndexMetadataReadAction(anyString(), anyString(), latchCapture.capture())).thenReturn(
-            mockRunnable
-        );
+        doAnswer(invocation -> {
+            latchCapture.getValue().onResponse(mockResult);
+            return null;
+        }).when(mockIndexMetadataManager).readAsync(anyString(), any(), latchCapture.capture());
         RemoteGlobalMetadataManager mockGlobalMetadataManager = mock(RemoteGlobalMetadataManager.class);
-        when(mockGlobalMetadataManager.getAsyncMetadataReadAction(any(), anyString(), latchCapture.capture())).thenReturn(mockRunnable);
+        doAnswer(invocation -> {
+            latchCapture.getValue().onResponse(mockResult);
+            return null;
+        }).when(mockGlobalMetadataManager).readAsync(any(), any(), latchCapture.capture());
         RemoteClusterStateAttributesManager mockClusterStateAttributeManager = mock(RemoteClusterStateAttributesManager.class);
-        when(mockClusterStateAttributeManager.getAsyncMetadataReadAction(anyString(), any(), latchCapture.capture())).thenReturn(
-            mockRunnable
-        );
-        doAnswer(invocationOnMock -> {
+        doAnswer(invocation -> {
             latchCapture.getValue().onResponse(mockResult);
             return null;
-        }).when(mockRunnable).run();
+        }).when(mockClusterStateAttributeManager).readAsync(anyString(), any(), latchCapture.capture());
         when(mockResult.getComponent()).thenReturn("mock-result");
         remoteClusterStateService.start();
         remoteClusterStateService.setRemoteIndexMetadataManager(mockIndexMetadataManager);
@@ -1357,61 +1429,62 @@ public void testReadClusterStateInParallel_UnexpectedResult() throws IOException
                 emptyList(),
                 true,
                 newClusterStateCustoms,
+                false,
                 true
             )
         );
         assertEquals("Unknown component: mock-result", exception.getMessage());
         newIndicesToRead.forEach(
-            uploadedIndexMetadata -> verify(mockIndexMetadataManager, times(1)).getAsyncIndexMetadataReadAction(
-                eq(previousClusterState.getMetadata().clusterUUID()),
-                eq(uploadedIndexMetadata.getUploadedFilename()),
+            uploadedIndexMetadata -> verify(mockIndexMetadataManager, times(1)).readAsync(
+                eq("test-index-1"),
+                argThat(new BlobNameMatcher(uploadedIndexMetadata.getUploadedFilename())),
                 any()
             )
         );
-        verify(mockGlobalMetadataManager, times(1)).getAsyncMetadataReadAction(
-            argThat(new BlobNameMatcher(COORDINATION_METADATA_FILENAME)),
+        verify(mockGlobalMetadataManager, times(1)).readAsync(
             eq(COORDINATION_METADATA),
+            argThat(new BlobNameMatcher(COORDINATION_METADATA_FILENAME)),
             any()
         );
-        verify(mockGlobalMetadataManager, times(1)).getAsyncMetadataReadAction(
-            argThat(new BlobNameMatcher(PERSISTENT_SETTINGS_FILENAME)),
+        verify(mockGlobalMetadataManager, times(1)).readAsync(
             eq(SETTING_METADATA),
+            argThat(new BlobNameMatcher(PERSISTENT_SETTINGS_FILENAME)),
             any()
         );
-        verify(mockGlobalMetadataManager, times(1)).getAsyncMetadataReadAction(
-            argThat(new BlobNameMatcher(TRANSIENT_SETTINGS_FILENAME)),
+        verify(mockGlobalMetadataManager, times(1)).readAsync(
             eq(TRANSIENT_SETTING_METADATA),
+            argThat(new BlobNameMatcher(TRANSIENT_SETTINGS_FILENAME)),
             any()
         );
-        verify(mockGlobalMetadataManager, times(1)).getAsyncMetadataReadAction(
-            argThat(new BlobNameMatcher(TEMPLATES_METADATA_FILENAME)),
+        verify(mockGlobalMetadataManager, times(1)).readAsync(
             eq(TEMPLATES_METADATA),
+            argThat(new BlobNameMatcher(TEMPLATES_METADATA_FILENAME)),
             any()
         );
-        verify(mockGlobalMetadataManager, times(1)).getAsyncMetadataReadAction(
-            argThat(new BlobNameMatcher(HASHES_OF_CONSISTENT_SETTINGS_FILENAME)),
+        verify(mockGlobalMetadataManager, times(1)).readAsync(
             eq(HASHES_OF_CONSISTENT_SETTINGS),
+            argThat(new BlobNameMatcher(HASHES_OF_CONSISTENT_SETTINGS_FILENAME)),
             any()
         );
         newCustomMetadataMap.keySet().forEach(uploadedCustomMetadataKey -> {
-            verify(mockGlobalMetadataManager, times(1)).getAsyncMetadataReadAction(
-                argThat(new BlobNameMatcher(newCustomMetadataMap.get(uploadedCustomMetadataKey).getUploadedFilename())),
+            verify(mockGlobalMetadataManager, times(1)).readAsync(
                 eq(uploadedCustomMetadataKey),
+                argThat(new BlobNameMatcher(newCustomMetadataMap.get(uploadedCustomMetadataKey).getUploadedFilename())),
                 any()
             );
         });
-        verify(mockClusterStateAttributeManager, times(1)).getAsyncMetadataReadAction(
+        verify(mockClusterStateAttributeManager, times(1)).readAsync(
             eq(DISCOVERY_NODES),
             argThat(new BlobNameMatcher(DISCOVERY_NODES_FILENAME)),
             any()
         );
-        verify(mockClusterStateAttributeManager, times(1)).getAsyncMetadataReadAction(
+        verify(mockClusterStateAttributeManager, times(1)).readAsync(
             eq(CLUSTER_BLOCKS),
             argThat(new BlobNameMatcher(CLUSTER_BLOCKS_FILENAME)),
             any()
         );
         newClusterStateCustoms.keySet().forEach(uploadedClusterStateCustomMetadataKey -> {
-            verify(mockClusterStateAttributeManager, times(1)).getAsyncMetadataReadAction(
+            verify(mockClusterStateAttributeManager, times(1)).readAsync(
                 eq(String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, uploadedClusterStateCustomMetadataKey)),
                 argThat(new BlobNameMatcher(newClusterStateCustoms.get(uploadedClusterStateCustomMetadataKey).getUploadedFilename())),
                 any()
@@ -1494,131 +1567,81 @@ public void testReadClusterStateInParallel_Success() throws IOException {
         RemoteGlobalMetadataManager mockedGlobalMetadataManager = mock(RemoteGlobalMetadataManager.class);
         RemoteClusterStateAttributesManager mockedClusterStateAttributeManager = mock(RemoteClusterStateAttributesManager.class);
 
-        when(
-            mockedIndexManager.getAsyncIndexMetadataReadAction(
-                eq(manifest.getClusterUUID()),
-                eq(indexFilename),
-                any(LatchedActionListener.class)
-            )
-        ).thenAnswer(invocationOnMock -> {
+        doAnswer(invocationOnMock -> {
             LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
-            return (CheckedRunnable<IOException>) () -> latchedActionListener.onResponse(
-                new RemoteReadResult(newIndexMetadata, INDEX, "test-index-1")
-            );
-        });
-        when(
-            mockedGlobalMetadataManager.getAsyncMetadataReadAction(
-                argThat(new BlobNameMatcher(customMetadataFilename)),
-                eq("custom_md_3"),
-                any()
-            )
-        ).thenAnswer(invocationOnMock -> {
+            latchedActionListener.onResponse(new RemoteReadResult(newIndexMetadata, INDEX, "test-index-1"));
+            return null;
+        }).when(mockedIndexManager)
+            .readAsync(eq("test-index-1"), argThat(new BlobNameMatcher(indexFilename)), any(LatchedActionListener.class));
+        doAnswer(invocationOnMock -> {
             LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
-            return (CheckedRunnable<IOException>) () -> latchedActionListener.onResponse(
-                new RemoteReadResult(customMetadata3, CUSTOM_METADATA, "custom_md_3")
-            );
-        });
-        when(
-            mockedGlobalMetadataManager.getAsyncMetadataReadAction(
-                argThat(new BlobNameMatcher(COORDINATION_METADATA_FILENAME)),
-                eq(COORDINATION_METADATA),
-                any()
-            )
-        ).thenAnswer(invocationOnMock -> {
+            latchedActionListener.onResponse(new RemoteReadResult(customMetadata3, CUSTOM_METADATA, "custom_md_3"));
+            return null;
+        }).when(mockedGlobalMetadataManager).readAsync(eq("custom_md_3"), argThat(new BlobNameMatcher(customMetadataFilename)), any());
+        doAnswer(invocationOnMock -> {
             LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
-            return (CheckedRunnable<IOException>) () -> latchedActionListener.onResponse(
+            latchedActionListener.onResponse(
                 new RemoteReadResult(updatedCoordinationMetadata, COORDINATION_METADATA, COORDINATION_METADATA)
             );
-        });
-        when(
-            mockedGlobalMetadataManager.getAsyncMetadataReadAction(
-                argThat(new BlobNameMatcher(PERSISTENT_SETTINGS_FILENAME)),
-                eq(SETTING_METADATA),
-                any()
-            )
-        ).thenAnswer(invocationOnMock -> {
+            return null;
+        }).when(mockedGlobalMetadataManager)
+            .readAsync(eq(COORDINATION_METADATA), argThat(new BlobNameMatcher(COORDINATION_METADATA_FILENAME)), any());
+        doAnswer(invocationOnMock -> {
             LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
-
-            return (CheckedRunnable<IOException>) () -> latchedActionListener.onResponse(
-                new RemoteReadResult(updatedPersistentSettings, SETTING_METADATA, SETTING_METADATA)
-            );
-        });
-        when(
-            mockedGlobalMetadataManager.getAsyncMetadataReadAction(
-                argThat(new BlobNameMatcher(TRANSIENT_SETTINGS_FILENAME)),
-                eq(TRANSIENT_SETTING_METADATA),
-                any()
-            )
-        ).thenAnswer(invocationOnMock -> {
+            latchedActionListener.onResponse(new RemoteReadResult(updatedPersistentSettings, SETTING_METADATA, SETTING_METADATA));
+            return null;
+        }).when(mockedGlobalMetadataManager)
+            .readAsync(eq(SETTING_METADATA), argThat(new BlobNameMatcher(PERSISTENT_SETTINGS_FILENAME)), any());
+        doAnswer(invocationOnMock -> {
             LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
-            return (CheckedRunnable<IOException>) () -> latchedActionListener.onResponse(
+            latchedActionListener.onResponse(
                 new RemoteReadResult(updatedTransientSettings, TRANSIENT_SETTING_METADATA, TRANSIENT_SETTING_METADATA)
             );
-        });
-        when(
-            mockedGlobalMetadataManager.getAsyncMetadataReadAction(
-                argThat(new BlobNameMatcher(TEMPLATES_METADATA_FILENAME)),
-                eq(TEMPLATES_METADATA),
-                any()
-            )
-        ).thenAnswer(invocationOnMock -> {
+            return null;
+        }).when(mockedGlobalMetadataManager)
+            .readAsync(eq(TRANSIENT_SETTING_METADATA), argThat(new BlobNameMatcher(TRANSIENT_SETTINGS_FILENAME)), any());
+        doAnswer(invocationOnMock -> {
             LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
-            return (CheckedRunnable<IOException>) () -> latchedActionListener.onResponse(
-                new RemoteReadResult(updatedTemplateMetadata, TEMPLATES_METADATA, TEMPLATES_METADATA)
-            );
-        });
-        when(
-            mockedGlobalMetadataManager.getAsyncMetadataReadAction(
-                argThat(new BlobNameMatcher(HASHES_OF_CONSISTENT_SETTINGS_FILENAME)),
-                eq(HASHES_OF_CONSISTENT_SETTINGS),
-                any()
-            )
-        ).thenAnswer(invocationOnMock -> {
+            latchedActionListener.onResponse(new RemoteReadResult(updatedTemplateMetadata, TEMPLATES_METADATA, TEMPLATES_METADATA));
+            return null;
+        }).when(mockedGlobalMetadataManager)
+            .readAsync(eq(TEMPLATES_METADATA), argThat(new BlobNameMatcher(TEMPLATES_METADATA_FILENAME)), any());
+        doAnswer(invocationOnMock -> {
             LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
-            return (CheckedRunnable<IOException>) () -> latchedActionListener.onResponse(
+            latchedActionListener.onResponse(
                 new RemoteReadResult(updatedHashesOfConsistentSettings, HASHES_OF_CONSISTENT_SETTINGS, HASHES_OF_CONSISTENT_SETTINGS)
             );
-        });
-        when(
-            mockedClusterStateAttributeManager.getAsyncMetadataReadAction(
-                eq(DISCOVERY_NODES),
-                argThat(new BlobNameMatcher(DISCOVERY_NODES_FILENAME)),
-                any()
-            )
-        ).thenAnswer(invocationOnMock -> {
+            return null;
+        }).when(mockedGlobalMetadataManager)
+            .readAsync(eq(HASHES_OF_CONSISTENT_SETTINGS), argThat(new BlobNameMatcher(HASHES_OF_CONSISTENT_SETTINGS_FILENAME)), any());
+        doAnswer(invocationOnMock -> {
             LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
-            return (CheckedRunnable<IOException>) () -> latchedActionListener.onResponse(
-                new RemoteReadResult(updatedDiscoveryNodes, CLUSTER_STATE_ATTRIBUTE, DISCOVERY_NODES)
-            );
-        });
-        when(
-            mockedClusterStateAttributeManager.getAsyncMetadataReadAction(
-                eq(CLUSTER_BLOCKS),
-                argThat(new BlobNameMatcher(CLUSTER_BLOCKS_FILENAME)),
-                any()
-            )
-        ).thenAnswer(invocationOnMock -> {
+            latchedActionListener.onResponse(new RemoteReadResult(updatedDiscoveryNodes, CLUSTER_STATE_ATTRIBUTE, DISCOVERY_NODES));
+            return null;
+        }).when(mockedClusterStateAttributeManager)
+            .readAsync(eq(DISCOVERY_NODES), argThat(new BlobNameMatcher(DISCOVERY_NODES_FILENAME)), any());
+        doAnswer(invocationOnMock -> {
             LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
-            return (CheckedRunnable<IOException>) () -> latchedActionListener.onResponse(
-                new RemoteReadResult(updatedClusterBlocks, CLUSTER_STATE_ATTRIBUTE, CLUSTER_BLOCKS)
-            );
-        });
-        when(
-            mockedClusterStateAttributeManager.getAsyncMetadataReadAction(
-                eq(String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, updatedClusterStateCustom3.getWriteableName())),
-                argThat(new BlobNameMatcher(clusterStateCustomFilename)),
-                any()
-            )
-        ).thenAnswer(invocationOnMock -> {
+            latchedActionListener.onResponse(new RemoteReadResult(updatedClusterBlocks, CLUSTER_STATE_ATTRIBUTE, CLUSTER_BLOCKS));
+            return null;
+        }).when(mockedClusterStateAttributeManager)
+            .readAsync(eq(CLUSTER_BLOCKS), argThat(new BlobNameMatcher(CLUSTER_BLOCKS_FILENAME)), any());
+        doAnswer(invocationOnMock -> {
             LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
-            return (CheckedRunnable<IOException>) () -> latchedActionListener.onResponse(
+            latchedActionListener.onResponse(
                 new RemoteReadResult(
                     updatedClusterStateCustom3,
                     CLUSTER_STATE_ATTRIBUTE,
                     String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, updatedClusterStateCustom3.getWriteableName())
                 )
             );
-        });
+            return null;
+        }).when(mockedClusterStateAttributeManager)
+            .readAsync(
+                eq(String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, updatedClusterStateCustom3.getWriteableName())),
+                argThat(new BlobNameMatcher(clusterStateCustomFilename)),
+                any()
+            );
 
         remoteClusterStateService.start();
         remoteClusterStateService.setRemoteIndexMetadataManager(mockedIndexManager);
@@ -1641,6 +1664,7 @@ public void testReadClusterStateInParallel_Success() throws IOException {
             emptyList(),
             true,
             newClusterStateCustoms,
+            false,
             true
         );
 
@@ -1664,56 +1688,56 @@ public void testReadClusterStateInParallel_Success() throws IOException {
         uploadedClusterStateCustomMap.keySet().forEach(key -> assertTrue(updatedClusterState.customs().containsKey(key)));
         assertEquals(updatedClusterStateCustom3, updatedClusterState.custom("custom_3"));
         newIndicesToRead.forEach(
-            uploadedIndexMetadata -> verify(mockedIndexManager, times(1)).getAsyncIndexMetadataReadAction(
-                eq(previousClusterState.getMetadata().clusterUUID()),
-                eq(uploadedIndexMetadata.getUploadedFilename()),
+            uploadedIndexMetadata -> verify(mockedIndexManager, times(1)).readAsync(
+                eq("test-index-1"),
+                argThat(new BlobNameMatcher(uploadedIndexMetadata.getUploadedFilename())),
                 any()
             )
         );
-        verify(mockedGlobalMetadataManager, times(1)).getAsyncMetadataReadAction(
-            argThat(new BlobNameMatcher(COORDINATION_METADATA_FILENAME)),
+        verify(mockedGlobalMetadataManager, times(1)).readAsync(
             eq(COORDINATION_METADATA),
+            argThat(new BlobNameMatcher(COORDINATION_METADATA_FILENAME)),
             any()
         );
-        verify(mockedGlobalMetadataManager, times(1)).getAsyncMetadataReadAction(
-            argThat(new BlobNameMatcher(PERSISTENT_SETTINGS_FILENAME)),
+        verify(mockedGlobalMetadataManager, times(1)).readAsync(
             eq(SETTING_METADATA),
+            argThat(new BlobNameMatcher(PERSISTENT_SETTINGS_FILENAME)),
             any()
         );
-        verify(mockedGlobalMetadataManager, times(1)).getAsyncMetadataReadAction(
-            argThat(new BlobNameMatcher(TRANSIENT_SETTINGS_FILENAME)),
+        verify(mockedGlobalMetadataManager, times(1)).readAsync(
             eq(TRANSIENT_SETTING_METADATA),
+            argThat(new BlobNameMatcher(TRANSIENT_SETTINGS_FILENAME)),
             any()
         );
-        verify(mockedGlobalMetadataManager, times(1)).getAsyncMetadataReadAction(
-            argThat(new BlobNameMatcher(TEMPLATES_METADATA_FILENAME)),
+        verify(mockedGlobalMetadataManager, times(1)).readAsync(
             eq(TEMPLATES_METADATA),
+            argThat(new BlobNameMatcher(TEMPLATES_METADATA_FILENAME)),
             any()
         );
-        verify(mockedGlobalMetadataManager, times(1)).getAsyncMetadataReadAction(
-            argThat(new BlobNameMatcher(HASHES_OF_CONSISTENT_SETTINGS_FILENAME)),
+        verify(mockedGlobalMetadataManager, times(1)).readAsync(
             eq(HASHES_OF_CONSISTENT_SETTINGS),
+            argThat(new BlobNameMatcher(HASHES_OF_CONSISTENT_SETTINGS_FILENAME)),
             any()
         );
         newCustomMetadataMap.keySet().forEach(uploadedCustomMetadataKey -> {
-            verify(mockedGlobalMetadataManager, times(1)).getAsyncMetadataReadAction(
-                argThat(new BlobNameMatcher(newCustomMetadataMap.get(uploadedCustomMetadataKey).getUploadedFilename())),
+            verify(mockedGlobalMetadataManager, times(1)).readAsync(
                 eq(uploadedCustomMetadataKey),
+                argThat(new BlobNameMatcher(newCustomMetadataMap.get(uploadedCustomMetadataKey).getUploadedFilename())),
                 any()
             );
         });
-        verify(mockedClusterStateAttributeManager, times(1)).getAsyncMetadataReadAction(
+        verify(mockedClusterStateAttributeManager, times(1)).readAsync(
             eq(DISCOVERY_NODES),
             argThat(new BlobNameMatcher(DISCOVERY_NODES_FILENAME)),
             any()
         );
-        verify(mockedClusterStateAttributeManager, times(1)).getAsyncMetadataReadAction(
+        verify(mockedClusterStateAttributeManager, times(1)).readAsync(
             eq(CLUSTER_BLOCKS),
             argThat(new BlobNameMatcher(CLUSTER_BLOCKS_FILENAME)),
             any()
         );
         newClusterStateCustoms.keySet().forEach(uploadedClusterStateCustomMetadataKey -> {
-            verify(mockedClusterStateAttributeManager, times(1)).getAsyncMetadataReadAction(
+            verify(mockedClusterStateAttributeManager, times(1)).readAsync(
                 eq(String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, uploadedClusterStateCustomMetadataKey)),
                 argThat(new BlobNameMatcher(newClusterStateCustoms.get(uploadedClusterStateCustomMetadataKey).getUploadedFilename())),
                 any()
@@ -2603,7 +2627,7 @@ public void testWriteFullMetadataSuccessWithRoutingTable() throws IOException {
             "test-index",
             "index-uuid",
             "routing-filename",
-            InternalRemoteRoutingTableService.INDEX_ROUTING_METADATA_PREFIX
+            INDEX_ROUTING_METADATA_PREFIX
         );
         final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
             .indices(List.of(uploadedIndexMetadata))
@@ -2654,7 +2678,7 @@ public void testWriteFullMetadataInParallelSuccessWithRoutingTable() throws IOEx
             "test-index",
             "index-uuid",
             "routing-filename",
-            InternalRemoteRoutingTableService.INDEX_ROUTING_METADATA_PREFIX
+            INDEX_ROUTING_METADATA_PREFIX
         );
 
         final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
@@ -2710,7 +2734,7 @@ public void testWriteIncrementalMetadataSuccessWithRoutingTable() throws IOExcep
             "test-index",
             "index-uuid",
             "routing-filename",
-            InternalRemoteRoutingTableService.INDEX_ROUTING_METADATA_PREFIX
+            INDEX_ROUTING_METADATA_PREFIX
         );
         final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
             .indices(List.of(uploadedIndexMetadata))
@@ -2734,6 +2758,108 @@ public void testWriteIncrementalMetadataSuccessWithRoutingTable() throws IOExcep
         assertThat(manifest.getIndicesRouting().get(0).getUploadedFilename(), notNullValue());
     }
 
+    public void testWriteIncrementalMetadataSuccessWithRoutingTableDiff() throws IOException {
+        initializeRoutingTable();
+        final ClusterState clusterState = generateClusterStateWithOneIndex("test-index", 5, 1, false).nodes(
+            nodesWithLocalNodeClusterManager()
+        ).build();
+        mockBlobStoreObjects();
+        List<UploadedIndexMetadata> indices = new ArrayList<>();
+        final UploadedIndexMetadata uploadedIndiceRoutingMetadata = new UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "routing-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
+        indices.add(uploadedIndiceRoutingMetadata);
+        final ClusterState previousClusterState = generateClusterStateWithOneIndex("test-index", 5, 1, true).nodes(
+            nodesWithLocalNodeClusterManager()
+        ).build();
+
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder().indices(indices).build();
+        when((blobStoreRepository.basePath())).thenReturn(BlobPath.cleanPath().add("base-path"));
+
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeIncrementalMetadata(
+            previousClusterState,
+            clusterState,
+            previousManifest
+        ).getClusterMetadataManifest();
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
+        final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
+            .indices(List.of(uploadedIndexMetadata))
+            .clusterTerm(clusterState.term())
+            .stateVersion(1L)
+            .stateUUID("state-uuid")
+            .clusterUUID("cluster-uuid")
+            .previousClusterUUID("prev-cluster-uuid")
+            .routingTableVersion(1)
+            .indicesRouting(List.of(uploadedIndiceRoutingMetadata))
+            .build();
+
+        assertThat(manifest.getIndices().size(), is(1));
+        assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
+        assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
+        assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
+        assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+        assertThat(manifest.getRoutingTableVersion(), is(expectedManifest.getRoutingTableVersion()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexName(), is(uploadedIndiceRoutingMetadata.getIndexName()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexUUID(), is(uploadedIndiceRoutingMetadata.getIndexUUID()));
+        assertThat(manifest.getIndicesRouting().get(0).getUploadedFilename(), notNullValue());
+        assertThat(manifest.getDiffManifest().getIndicesRoutingDiffPath(), notNullValue());
+    }
+
+    public void testWriteIncrementalMetadataSuccessWithRoutingTableDiffNull() throws IOException {
+        initializeRoutingTable();
+        final ClusterState clusterState = generateClusterStateWithOneIndex("test-index", 5, 1, false).nodes(
+            nodesWithLocalNodeClusterManager()
+        ).build();
+        mockBlobStoreObjects();
+        List<UploadedIndexMetadata> indices = new ArrayList<>();
+        final UploadedIndexMetadata uploadedIndiceRoutingMetadata = new UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "routing-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
+        indices.add(uploadedIndiceRoutingMetadata);
+        final ClusterState previousClusterState = generateClusterStateWithOneIndex("test-index2", 5, 1, false).nodes(
+            nodesWithLocalNodeClusterManager()
+        ).build();
+
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder().indices(indices).build();
+        when((blobStoreRepository.basePath())).thenReturn(BlobPath.cleanPath().add("base-path"));
+
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeIncrementalMetadata(
+            previousClusterState,
+            clusterState,
+            previousManifest
+        ).getClusterMetadataManifest();
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
+        final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
+            .indices(List.of(uploadedIndexMetadata))
+            .clusterTerm(clusterState.term())
+            .stateVersion(1L)
+            .stateUUID("state-uuid")
+            .clusterUUID("cluster-uuid")
+            .previousClusterUUID("prev-cluster-uuid")
+            .routingTableVersion(1)
+            .indicesRouting(List.of(uploadedIndiceRoutingMetadata))
+            .build();
+
+        assertThat(manifest.getIndices().size(), is(1));
+        assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
+        assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
+        assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
+        assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+        assertThat(manifest.getRoutingTableVersion(), is(expectedManifest.getRoutingTableVersion()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexName(), is(uploadedIndiceRoutingMetadata.getIndexName()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexUUID(), is(uploadedIndiceRoutingMetadata.getIndexUUID()));
+        assertThat(manifest.getIndicesRouting().get(0).getUploadedFilename(), notNullValue());
+        assertThat(manifest.getDiffManifest().getIndicesRoutingDiffPath(), nullValue());
+    }
+
     private void initializeRoutingTable() {
         Settings newSettings = Settings.builder()
             .put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, "routing_repository")
@@ -3206,6 +3332,54 @@ static ClusterState.Builder generateClusterStateWithOneIndex() {
             .routingTable(RoutingTable.builder().addAsNew(indexMetadata).version(1L).build());
     }
 
+    public static ClusterState.Builder generateClusterStateWithOneIndex(
+        String indexName,
+        int primaryShards,
+        int replicaShards,
+        boolean addAsNew
+    ) {
+
+        final Index index = new Index(indexName, "index-uuid");
+        final Settings idxSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, index.getUUID())
+            .build();
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder(index.getName()).settings(idxSettings)
+            .numberOfShards(primaryShards)
+            .numberOfReplicas(replicaShards)
+            .build();
+        final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
+        final Settings settings = Settings.builder().put("mock-settings", true).build();
+        final TemplatesMetadata templatesMetadata = TemplatesMetadata.builder()
+            .put(IndexTemplateMetadata.builder("template1").settings(idxSettings).patterns(List.of("test*")).build())
+            .build();
+        final CustomMetadata1 customMetadata1 = new CustomMetadata1("custom-metadata-1");
+
+        RoutingTable.Builder routingTableBuilder = RoutingTable.builder();
+        if (addAsNew) {
+            routingTableBuilder.addAsNew(indexMetadata);
+        } else {
+            routingTableBuilder.addAsRecovery(indexMetadata);
+        }
+
+        return ClusterState.builder(ClusterName.DEFAULT)
+            .version(1L)
+            .stateUUID("state-uuid")
+            .metadata(
+                Metadata.builder()
+                    .version(randomNonNegativeLong())
+                    .put(indexMetadata, true)
+                    .clusterUUID("cluster-uuid")
+                    .coordinationMetadata(coordinationMetadata)
+                    .persistentSettings(settings)
+                    .templates(templatesMetadata)
+                    .hashesOfConsistentSettings(Map.of("key1", "value1", "key2", "value2"))
+                    .putCustom(customMetadata1.getWriteableName(), customMetadata1)
+                    .build()
+            )
+            .routingTable(routingTableBuilder.version(1L).build());
+    }
+
     static ClusterState.Builder generateClusterStateWithAllAttributes() {
         final Index index = new Index("test-index", "index-uuid");
         final Settings idxSettings = Settings.builder()
@@ -3285,7 +3459,7 @@ static ClusterMetadataManifest.Builder generateClusterMetadataManifestWithAllAtt
             );
     }
 
-    static DiscoveryNodes nodesWithLocalNodeClusterManager() {
+    public static DiscoveryNodes nodesWithLocalNodeClusterManager() {
         final DiscoveryNode localNode = new DiscoveryNode("cluster-manager-id", buildNewFakeTransportAddress(), Version.CURRENT);
         return DiscoveryNodes.builder().clusterManagerNodeId("cluster-manager-id").localNodeId("cluster-manager-id").add(localNode).build();
     }
diff --git a/server/src/test/java/org/opensearch/gateway/remote/RemoteGlobalMetadataManagerTests.java b/server/src/test/java/org/opensearch/gateway/remote/RemoteGlobalMetadataManagerTests.java
index 917794ec03c3a..a2da1e8b0fdb2 100644
--- a/server/src/test/java/org/opensearch/gateway/remote/RemoteGlobalMetadataManagerTests.java
+++ b/server/src/test/java/org/opensearch/gateway/remote/RemoteGlobalMetadataManagerTests.java
@@ -158,7 +158,7 @@ public void testGlobalMetadataUploadWaitTimeSetting() {
         assertEquals(globalMetadataUploadTimeout, remoteGlobalMetadataManager.getGlobalMetadataUploadTimeout().seconds());
     }
 
-    public void testGetReadMetadataAsyncAction_CoordinationMetadata() throws Exception {
+    public void testGetAsyncReadRunnable_CoordinationMetadata() throws Exception {
         CoordinationMetadata coordinationMetadata = getCoordinationMetadata();
         String fileName = randomAlphaOfLength(10);
         RemoteCoordinationMetadata coordinationMetadataForDownload = new RemoteCoordinationMetadata(
@@ -173,11 +173,11 @@ public void testGetReadMetadataAsyncAction_CoordinationMetadata() throws Excepti
         TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
 
-        remoteGlobalMetadataManager.getAsyncMetadataReadAction(
-            coordinationMetadataForDownload,
+        remoteGlobalMetadataManager.readAsync(
             COORDINATION_METADATA,
+            coordinationMetadataForDownload,
             new LatchedActionListener<>(listener, latch)
-        ).run();
+        );
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -186,7 +186,7 @@ public void testGetReadMetadataAsyncAction_CoordinationMetadata() throws Excepti
         assertEquals(COORDINATION_METADATA, listener.getResult().getComponentName());
     }
 
-    public void testGetAsyncMetadataWriteAction_CoordinationMetadata() throws Exception {
+    public void testGetAsyncWriteRunnable_CoordinationMetadata() throws Exception {
         CoordinationMetadata coordinationMetadata = getCoordinationMetadata();
         RemoteCoordinationMetadata remoteCoordinationMetadata = new RemoteCoordinationMetadata(
             coordinationMetadata,
@@ -203,8 +203,11 @@ public void testGetAsyncMetadataWriteAction_CoordinationMetadata() throws Except
         TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
 
-        remoteGlobalMetadataManager.getAsyncMetadataWriteAction(remoteCoordinationMetadata, new LatchedActionListener<>(listener, latch))
-            .run();
+        remoteGlobalMetadataManager.writeAsync(
+            COORDINATION_METADATA,
+            remoteCoordinationMetadata,
+            new LatchedActionListener<>(listener, latch)
+        );
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -224,7 +227,7 @@ public void testGetAsyncMetadataWriteAction_CoordinationMetadata() throws Except
         assertEquals(GLOBAL_METADATA_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
     }
 
-    public void testGetReadMetadataAsyncAction_PersistentSettings() throws Exception {
+    public void testGetAsyncReadRunnable_PersistentSettings() throws Exception {
         Settings settingsMetadata = getSettings();
         String fileName = randomAlphaOfLength(10);
         RemotePersistentSettingsMetadata persistentSettings = new RemotePersistentSettingsMetadata(
@@ -240,11 +243,7 @@ public void testGetReadMetadataAsyncAction_PersistentSettings() throws Exception
         TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
 
-        remoteGlobalMetadataManager.getAsyncMetadataReadAction(
-            persistentSettings,
-            SETTING_METADATA,
-            new LatchedActionListener<>(listener, latch)
-        ).run();
+        remoteGlobalMetadataManager.readAsync(SETTING_METADATA, persistentSettings, new LatchedActionListener<>(listener, latch));
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -253,7 +252,7 @@ public void testGetReadMetadataAsyncAction_PersistentSettings() throws Exception
         assertEquals(SETTING_METADATA, listener.getResult().getComponentName());
     }
 
-    public void testGetAsyncMetadataWriteAction_PersistentSettings() throws Exception {
+    public void testGetAsyncWriteRunnable_PersistentSettings() throws Exception {
         Settings settingsMetadata = getSettings();
         RemotePersistentSettingsMetadata persistentSettings = new RemotePersistentSettingsMetadata(
             settingsMetadata,
@@ -269,7 +268,7 @@ public void testGetAsyncMetadataWriteAction_PersistentSettings() throws Exceptio
             .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
         TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
-        remoteGlobalMetadataManager.getAsyncMetadataWriteAction(persistentSettings, new LatchedActionListener<>(listener, latch)).run();
+        remoteGlobalMetadataManager.writeAsync(SETTING_METADATA, persistentSettings, new LatchedActionListener<>(listener, latch));
 
         latch.await();
         assertNull(listener.getFailure());
@@ -290,7 +289,7 @@ public void testGetAsyncMetadataWriteAction_PersistentSettings() throws Exceptio
         assertEquals(GLOBAL_METADATA_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
     }
 
-    public void testGetReadMetadataAsyncAction_TransientSettings() throws Exception {
+    public void testGetAsyncReadRunnable_TransientSettings() throws Exception {
         Settings settingsMetadata = getSettings();
         String fileName = randomAlphaOfLength(10);
         RemoteTransientSettingsMetadata transientSettings = new RemoteTransientSettingsMetadata(
@@ -306,11 +305,7 @@ public void testGetReadMetadataAsyncAction_TransientSettings() throws Exception
         TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
 
-        remoteGlobalMetadataManager.getAsyncMetadataReadAction(
-            transientSettings,
-            TRANSIENT_SETTING_METADATA,
-            new LatchedActionListener<>(listener, latch)
-        ).run();
+        remoteGlobalMetadataManager.readAsync(TRANSIENT_SETTING_METADATA, transientSettings, new LatchedActionListener<>(listener, latch));
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -319,7 +314,7 @@ public void testGetReadMetadataAsyncAction_TransientSettings() throws Exception
         assertEquals(TRANSIENT_SETTING_METADATA, listener.getResult().getComponentName());
     }
 
-    public void testGetAsyncMetadataWriteAction_TransientSettings() throws Exception {
+    public void testGetAsyncWriteRunnable_TransientSettings() throws Exception {
         Settings settingsMetadata = getSettings();
         RemoteTransientSettingsMetadata transientSettings = new RemoteTransientSettingsMetadata(
             settingsMetadata,
@@ -335,7 +330,7 @@ public void testGetAsyncMetadataWriteAction_TransientSettings() throws Exception
             .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
         TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
-        remoteGlobalMetadataManager.getAsyncMetadataWriteAction(transientSettings, new LatchedActionListener<>(listener, latch)).run();
+        remoteGlobalMetadataManager.writeAsync(TRANSIENT_SETTING_METADATA, transientSettings, new LatchedActionListener<>(listener, latch));
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -355,7 +350,7 @@ public void testGetAsyncMetadataWriteAction_TransientSettings() throws Exception
         assertEquals(GLOBAL_METADATA_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
     }
 
-    public void testGetReadMetadataAsyncAction_HashesOfConsistentSettings() throws Exception {
+    public void testGetAsyncReadRunnable_HashesOfConsistentSettings() throws Exception {
         DiffableStringMap hashesOfConsistentSettings = getHashesOfConsistentSettings();
         String fileName = randomAlphaOfLength(10);
         RemoteHashesOfConsistentSettings hashesOfConsistentSettingsForDownload = new RemoteHashesOfConsistentSettings(
@@ -369,11 +364,11 @@ public void testGetReadMetadataAsyncAction_HashesOfConsistentSettings() throws E
         TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
 
-        remoteGlobalMetadataManager.getAsyncMetadataReadAction(
-            hashesOfConsistentSettingsForDownload,
+        remoteGlobalMetadataManager.readAsync(
             HASHES_OF_CONSISTENT_SETTINGS,
+            hashesOfConsistentSettingsForDownload,
             new LatchedActionListener<>(listener, latch)
-        ).run();
+        );
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -382,7 +377,7 @@ public void testGetReadMetadataAsyncAction_HashesOfConsistentSettings() throws E
         assertEquals(HASHES_OF_CONSISTENT_SETTINGS, listener.getResult().getComponentName());
     }
 
-    public void testGetAsyncMetadataWriteAction_HashesOfConsistentSettings() throws Exception {
+    public void testGetAsyncWriteRunnable_HashesOfConsistentSettings() throws Exception {
         DiffableStringMap hashesOfConsistentSettings = getHashesOfConsistentSettings();
         RemoteHashesOfConsistentSettings hashesOfConsistentSettingsForUpload = new RemoteHashesOfConsistentSettings(
             hashesOfConsistentSettings,
@@ -397,10 +392,11 @@ public void testGetAsyncMetadataWriteAction_HashesOfConsistentSettings() throws
             .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
         TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
-        remoteGlobalMetadataManager.getAsyncMetadataWriteAction(
+        remoteGlobalMetadataManager.writeAsync(
+            HASHES_OF_CONSISTENT_SETTINGS,
             hashesOfConsistentSettingsForUpload,
             new LatchedActionListener<>(listener, latch)
-        ).run();
+        );
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -420,7 +416,7 @@ public void testGetAsyncMetadataWriteAction_HashesOfConsistentSettings() throws
         assertEquals(GLOBAL_METADATA_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
     }
 
-    public void testGetReadMetadataAsyncAction_TemplatesMetadata() throws Exception {
+    public void testGetAsyncReadRunnable_TemplatesMetadata() throws Exception {
         TemplatesMetadata templatesMetadata = getTemplatesMetadata();
         String fileName = randomAlphaOfLength(10);
         RemoteTemplatesMetadata templatesMetadataForDownload = new RemoteTemplatesMetadata(
@@ -434,11 +430,11 @@ public void testGetReadMetadataAsyncAction_TemplatesMetadata() throws Exception
         );
         TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
-        remoteGlobalMetadataManager.getAsyncMetadataReadAction(
-            templatesMetadataForDownload,
+        remoteGlobalMetadataManager.readAsync(
             TEMPLATES_METADATA,
+            templatesMetadataForDownload,
             new LatchedActionListener<>(listener, latch)
-        ).run();
+        );
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -447,7 +443,7 @@ public void testGetReadMetadataAsyncAction_TemplatesMetadata() throws Exception
         assertEquals(TEMPLATES_METADATA, listener.getResult().getComponentName());
     }
 
-    public void testGetAsyncMetadataWriteAction_TemplatesMetadata() throws Exception {
+    public void testGetAsyncWriteRunnable_TemplatesMetadata() throws Exception {
         TemplatesMetadata templatesMetadata = getTemplatesMetadata();
         RemoteTemplatesMetadata templateMetadataForUpload = new RemoteTemplatesMetadata(
             templatesMetadata,
@@ -463,8 +459,7 @@ public void testGetAsyncMetadataWriteAction_TemplatesMetadata() throws Exception
             .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
         TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
-        remoteGlobalMetadataManager.getAsyncMetadataWriteAction(templateMetadataForUpload, new LatchedActionListener<>(listener, latch))
-            .run();
+        remoteGlobalMetadataManager.writeAsync(TEMPLATES_METADATA, templateMetadataForUpload, new LatchedActionListener<>(listener, latch));
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -484,7 +479,7 @@ public void testGetAsyncMetadataWriteAction_TemplatesMetadata() throws Exception
         assertEquals(GLOBAL_METADATA_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
     }
 
-    public void testGetReadMetadataAsyncAction_CustomMetadata() throws Exception {
+    public void testGetAsyncReadRunnable_CustomMetadata() throws Exception {
         Metadata.Custom customMetadata = getCustomMetadata();
         String fileName = randomAlphaOfLength(10);
         RemoteCustomMetadata customMetadataForDownload = new RemoteCustomMetadata(
@@ -499,11 +494,7 @@ public void testGetReadMetadataAsyncAction_CustomMetadata() throws Exception {
         );
         TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
-        remoteGlobalMetadataManager.getAsyncMetadataReadAction(
-            customMetadataForDownload,
-            IndexGraveyard.TYPE,
-            new LatchedActionListener<>(listener, latch)
-        ).run();
+        remoteGlobalMetadataManager.readAsync(IndexGraveyard.TYPE, customMetadataForDownload, new LatchedActionListener<>(listener, latch));
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -512,7 +503,7 @@ public void testGetReadMetadataAsyncAction_CustomMetadata() throws Exception {
         assertEquals(IndexGraveyard.TYPE, listener.getResult().getComponentName());
     }
 
-    public void testGetAsyncMetadataWriteAction_CustomMetadata() throws Exception {
+    public void testGetAsyncWriteRunnable_CustomMetadata() throws Exception {
         Metadata.Custom customMetadata = getCustomMetadata();
         RemoteCustomMetadata customMetadataForUpload = new RemoteCustomMetadata(
             customMetadata,
@@ -529,8 +520,11 @@ public void testGetAsyncMetadataWriteAction_CustomMetadata() throws Exception {
             .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
         TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
-        remoteGlobalMetadataManager.getAsyncMetadataWriteAction(customMetadataForUpload, new LatchedActionListener<>(listener, latch))
-            .run();
+        remoteGlobalMetadataManager.writeAsync(
+            customMetadataForUpload.getType(),
+            customMetadataForUpload,
+            new LatchedActionListener<>(listener, latch)
+        );
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -550,7 +544,7 @@ public void testGetAsyncMetadataWriteAction_CustomMetadata() throws Exception {
         assertEquals(GLOBAL_METADATA_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
     }
 
-    public void testGetReadMetadataAsyncAction_GlobalMetadata() throws Exception {
+    public void testGetAsyncReadRunnable_GlobalMetadata() throws Exception {
         Metadata metadata = getGlobalMetadata();
         String fileName = randomAlphaOfLength(10);
         RemoteGlobalMetadata globalMetadataForDownload = new RemoteGlobalMetadata(fileName, CLUSTER_UUID, compressor, xContentRegistry);
@@ -559,11 +553,7 @@ public void testGetReadMetadataAsyncAction_GlobalMetadata() throws Exception {
         );
         TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
-        remoteGlobalMetadataManager.getAsyncMetadataReadAction(
-            globalMetadataForDownload,
-            GLOBAL_METADATA,
-            new LatchedActionListener<>(listener, latch)
-        ).run();
+        remoteGlobalMetadataManager.readAsync(GLOBAL_METADATA, globalMetadataForDownload, new LatchedActionListener<>(listener, latch));
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
@@ -572,7 +562,7 @@ public void testGetReadMetadataAsyncAction_GlobalMetadata() throws Exception {
         assertEquals(GLOBAL_METADATA, listener.getResult().getComponentName());
     }
 
-    public void testGetReadMetadataAsyncAction_IOException() throws Exception {
+    public void testGetAsyncReadRunnable_IOException() throws Exception {
         String fileName = randomAlphaOfLength(10);
         RemoteCoordinationMetadata coordinationMetadataForDownload = new RemoteCoordinationMetadata(
             fileName,
@@ -584,18 +574,19 @@ public void testGetReadMetadataAsyncAction_IOException() throws Exception {
         when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenThrow(ioException);
         TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
-        remoteGlobalMetadataManager.getAsyncMetadataReadAction(
-            coordinationMetadataForDownload,
+        remoteGlobalMetadataManager.readAsync(
             COORDINATION_METADATA,
+            coordinationMetadataForDownload,
             new LatchedActionListener<>(listener, latch)
-        ).run();
+        );
         latch.await();
         assertNull(listener.getResult());
         assertNotNull(listener.getFailure());
-        assertEquals(ioException, listener.getFailure());
+        assertEquals(ioException, listener.getFailure().getCause());
+        assertTrue(listener.getFailure() instanceof RemoteStateTransferException);
     }
 
-    public void testGetAsyncMetadataWriteAction_IOException() throws Exception {
+    public void testGetAsyncWriteRunnable_IOException() throws Exception {
         CoordinationMetadata coordinationMetadata = getCoordinationMetadata();
         RemoteCoordinationMetadata remoteCoordinationMetadata = new RemoteCoordinationMetadata(
             coordinationMetadata,
@@ -613,8 +604,11 @@ public void testGetAsyncMetadataWriteAction_IOException() throws Exception {
 
         TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
-        remoteGlobalMetadataManager.getAsyncMetadataWriteAction(remoteCoordinationMetadata, new LatchedActionListener<>(listener, latch))
-            .run();
+        remoteGlobalMetadataManager.writeAsync(
+            COORDINATION_METADATA,
+            remoteCoordinationMetadata,
+            new LatchedActionListener<>(listener, latch)
+        );
         assertNull(listener.getResult());
         assertNotNull(listener.getFailure());
         assertTrue(listener.getFailure() instanceof RemoteStateTransferException);
diff --git a/server/src/test/java/org/opensearch/gateway/remote/RemoteIndexMetadataManagerTests.java b/server/src/test/java/org/opensearch/gateway/remote/RemoteIndexMetadataManagerTests.java
index 817fc7b55d09a..76c5792677ea0 100644
--- a/server/src/test/java/org/opensearch/gateway/remote/RemoteIndexMetadataManagerTests.java
+++ b/server/src/test/java/org/opensearch/gateway/remote/RemoteIndexMetadataManagerTests.java
@@ -24,6 +24,7 @@
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.compress.Compressor;
 import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.gateway.remote.model.RemoteIndexMetadata;
 import org.opensearch.gateway.remote.model.RemoteReadResult;
 import org.opensearch.index.remote.RemoteStoreUtils;
 import org.opensearch.index.translog.transfer.BlobStoreTransferService;
@@ -83,7 +84,7 @@ public void tearDown() throws Exception {
         threadPool.shutdown();
     }
 
-    public void testGetAsyncIndexMetadataWriteAction_Success() throws Exception {
+    public void testGetAsyncWriteRunnable_Success() throws Exception {
         IndexMetadata indexMetadata = getIndexMetadata(randomAlphaOfLength(10), randomBoolean(), randomAlphaOfLength(10));
         BlobContainer blobContainer = mock(AsyncMultiStreamBlobContainer.class);
         BlobStore blobStore = mock(BlobStore.class);
@@ -97,11 +98,11 @@ public void testGetAsyncIndexMetadataWriteAction_Success() throws Exception {
             return null;
         })).when(blobStoreTransferService).uploadBlob(any(), any(), any(), eq(WritePriority.URGENT), any(ActionListener.class));
 
-        remoteIndexMetadataManager.getAsyncIndexMetadataWriteAction(
-            indexMetadata,
-            "cluster-uuid",
+        remoteIndexMetadataManager.writeAsync(
+            INDEX,
+            new RemoteIndexMetadata(indexMetadata, "cluster-uuid", compressor, null),
             new LatchedActionListener<>(listener, latch)
-        ).run();
+        );
         latch.await();
 
         assertNull(listener.getFailure());
@@ -116,7 +117,7 @@ public void testGetAsyncIndexMetadataWriteAction_Success() throws Exception {
         assertTrue(pathTokens[6].startsWith(expectedFilePrefix));
     }
 
-    public void testGetAsyncIndexMetadataWriteAction_IOFailure() throws Exception {
+    public void testGetAsyncWriteRunnable_IOFailure() throws Exception {
         IndexMetadata indexMetadata = getIndexMetadata(randomAlphaOfLength(10), randomBoolean(), randomAlphaOfLength(10));
         BlobContainer blobContainer = mock(AsyncMultiStreamBlobContainer.class);
         BlobStore blobStore = mock(BlobStore.class);
@@ -129,18 +130,18 @@ public void testGetAsyncIndexMetadataWriteAction_IOFailure() throws Exception {
             return null;
         })).when(blobStoreTransferService).uploadBlob(any(), any(), any(), eq(WritePriority.URGENT), any(ActionListener.class));
 
-        remoteIndexMetadataManager.getAsyncIndexMetadataWriteAction(
-            indexMetadata,
-            "cluster-uuid",
+        remoteIndexMetadataManager.writeAsync(
+            INDEX,
+            new RemoteIndexMetadata(indexMetadata, "cluster-uuid", compressor, null),
             new LatchedActionListener<>(listener, latch)
-        ).run();
+        );
         latch.await();
         assertNull(listener.getResult());
         assertNotNull(listener.getFailure());
         assertTrue(listener.getFailure() instanceof RemoteStateTransferException);
     }
 
-    public void testGetAsyncIndexMetadataReadAction_Success() throws Exception {
+    public void testGetAsyncReadRunnable_Success() throws Exception {
         IndexMetadata indexMetadata = getIndexMetadata(randomAlphaOfLength(10), randomBoolean(), randomAlphaOfLength(10));
         String fileName = randomAlphaOfLength(10);
         fileName = fileName + DELIMITER + '2';
@@ -150,15 +151,18 @@ public void testGetAsyncIndexMetadataReadAction_Success() throws Exception {
         TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
 
-        remoteIndexMetadataManager.getAsyncIndexMetadataReadAction("cluster-uuid", fileName, new LatchedActionListener<>(listener, latch))
-            .run();
+        remoteIndexMetadataManager.readAsync(
+            INDEX,
+            new RemoteIndexMetadata(fileName, "cluster-uuid", compressor, null),
+            new LatchedActionListener<>(listener, latch)
+        );
         latch.await();
         assertNull(listener.getFailure());
         assertNotNull(listener.getResult());
         assertEquals(indexMetadata, listener.getResult().getObj());
     }
 
-    public void testGetAsyncIndexMetadataReadAction_IOFailure() throws Exception {
+    public void testGetAsyncReadRunnable_IOFailure() throws Exception {
         String fileName = randomAlphaOfLength(10);
         fileName = fileName + DELIMITER + '2';
         Exception exception = new IOException("testing failure");
@@ -166,12 +170,16 @@ public void testGetAsyncIndexMetadataReadAction_IOFailure() throws Exception {
         TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
         CountDownLatch latch = new CountDownLatch(1);
 
-        remoteIndexMetadataManager.getAsyncIndexMetadataReadAction("cluster-uuid", fileName, new LatchedActionListener<>(listener, latch))
-            .run();
+        remoteIndexMetadataManager.readAsync(
+            INDEX,
+            new RemoteIndexMetadata(fileName, "cluster-uuid", compressor, null),
+            new LatchedActionListener<>(listener, latch)
+        );
         latch.await();
         assertNull(listener.getResult());
         assertNotNull(listener.getFailure());
-        assertEquals(exception, listener.getFailure());
+        assertEquals(exception, listener.getFailure().getCause());
+        assertTrue(listener.getFailure() instanceof RemoteStateTransferException);
     }
 
     private IndexMetadata getIndexMetadata(String name, @Nullable Boolean writeIndex, String... aliases) {
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/ClusterStateDiffManifestTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/ClusterStateDiffManifestTests.java
index 897b2f5eeb25d..f89619a09cd52 100644
--- a/server/src/test/java/org/opensearch/gateway/remote/model/ClusterStateDiffManifestTests.java
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/ClusterStateDiffManifestTests.java
@@ -10,6 +10,7 @@
 
 import org.opensearch.Version;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.DiffableUtils;
 import org.opensearch.cluster.coordination.CoordinationMetadata;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.IndexTemplateMetadata;
@@ -17,6 +18,7 @@
 import org.opensearch.cluster.metadata.TemplatesMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.IndexRoutingTable;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.xcontent.json.JsonXContent;
 import org.opensearch.core.common.bytes.BytesReference;
@@ -40,7 +42,11 @@
 import static java.util.stream.Collectors.toList;
 import static org.opensearch.Version.CURRENT;
 import static org.opensearch.cluster.ClusterState.EMPTY_STATE;
+import static org.opensearch.cluster.routing.remote.RemoteRoutingTableService.CUSTOM_ROUTING_TABLE_DIFFABLE_VALUE_SERIALIZER;
 import static org.opensearch.core.common.transport.TransportAddress.META_ADDRESS;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V3;
+import static org.opensearch.gateway.remote.RemoteClusterStateServiceTests.generateClusterStateWithOneIndex;
+import static org.opensearch.gateway.remote.RemoteClusterStateServiceTests.nodesWithLocalNodeClusterManager;
 import static org.opensearch.gateway.remote.model.RemoteClusterBlocksTests.randomClusterBlocks;
 
 public class ClusterStateDiffManifestTests extends OpenSearchTestCase {
@@ -114,11 +120,70 @@ public void testClusterStateDiffManifestXContent() throws IOException {
         diffManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
         builder.endObject();
         try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
-            final ClusterStateDiffManifest parsedManifest = ClusterStateDiffManifest.fromXContent(parser);
+            final ClusterStateDiffManifest parsedManifest = ClusterStateDiffManifest.fromXContent(parser, CODEC_V3);
             assertEquals(diffManifest, parsedManifest);
         }
     }
 
+    public void testClusterStateWithRoutingTableDiffInDiffManifestXContent() throws IOException {
+        ClusterState initialState = generateClusterStateWithOneIndex("test-index", 5, 1, true).nodes(nodesWithLocalNodeClusterManager())
+            .build();
+
+        ClusterState updatedState = generateClusterStateWithOneIndex("test-index", 5, 2, false).nodes(nodesWithLocalNodeClusterManager())
+            .build();
+
+        ClusterStateDiffManifest diffManifest = verifyRoutingTableDiffManifest(initialState, updatedState);
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        diffManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final ClusterStateDiffManifest parsedManifest = ClusterStateDiffManifest.fromXContent(parser, CODEC_V3);
+            assertEquals(diffManifest, parsedManifest);
+        }
+    }
+
+    public void testClusterStateWithRoutingTableDiffInDiffManifestXContent1() throws IOException {
+        ClusterState initialState = generateClusterStateWithOneIndex("test-index", 5, 1, true).nodes(nodesWithLocalNodeClusterManager())
+            .build();
+
+        ClusterState updatedState = generateClusterStateWithOneIndex("test-index-1", 5, 2, false).nodes(nodesWithLocalNodeClusterManager())
+            .build();
+
+        ClusterStateDiffManifest diffManifest = verifyRoutingTableDiffManifest(initialState, updatedState);
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        diffManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final ClusterStateDiffManifest parsedManifest = ClusterStateDiffManifest.fromXContent(parser, CODEC_V3);
+            assertEquals(diffManifest, parsedManifest);
+        }
+    }
+
+    private ClusterStateDiffManifest verifyRoutingTableDiffManifest(ClusterState previousState, ClusterState currentState) {
+        // Create initial and updated IndexRoutingTable maps
+        Map<String, IndexRoutingTable> initialRoutingTableMap = previousState.getRoutingTable().indicesRouting();
+        Map<String, IndexRoutingTable> updatedRoutingTableMap = currentState.getRoutingTable().indicesRouting();
+
+        DiffableUtils.MapDiff<String, IndexRoutingTable, Map<String, IndexRoutingTable>> routingTableIncrementalDiff = DiffableUtils.diff(
+            initialRoutingTableMap,
+            updatedRoutingTableMap,
+            DiffableUtils.getStringKeySerializer(),
+            CUSTOM_ROUTING_TABLE_DIFFABLE_VALUE_SERIALIZER
+        );
+        ClusterStateDiffManifest manifest = new ClusterStateDiffManifest(
+            currentState,
+            previousState,
+            routingTableIncrementalDiff,
+            "indicesRoutingDiffPath"
+        );
+        assertEquals("indicesRoutingDiffPath", manifest.getIndicesRoutingDiffPath());
+        assertEquals(routingTableIncrementalDiff.getUpserts().size(), manifest.getIndicesRoutingUpdated().size());
+        assertEquals(routingTableIncrementalDiff.getDeletes().size(), manifest.getIndicesRoutingDeleted().size());
+        return manifest;
+    }
+
     private ClusterStateDiffManifest updateAndVerifyState(
         ClusterState initialState,
         List<IndexMetadata> indicesToAdd,
@@ -191,7 +256,7 @@ private ClusterStateDiffManifest updateAndVerifyState(
         }
         ClusterState updatedClusterState = clusterStateBuilder.metadata(metadataBuilder.build()).build();
 
-        ClusterStateDiffManifest manifest = new ClusterStateDiffManifest(updatedClusterState, initialState);
+        ClusterStateDiffManifest manifest = new ClusterStateDiffManifest(updatedClusterState, initialState, null, null);
         assertEquals(indicesToAdd.stream().map(im -> im.getIndex().getName()).collect(toList()), manifest.getIndicesUpdated());
         assertEquals(indicesToRemove, manifest.getIndicesDeleted());
         assertEquals(new ArrayList<>(customsToAdd.keySet()), manifest.getCustomMetadataUpdated());
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/RemoteRoutingTableBlobStoreTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteRoutingTableBlobStoreTests.java
new file mode 100644
index 0000000000000..ea0f3264cfe4f
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteRoutingTableBlobStoreTests.java
@@ -0,0 +1,133 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.index.Index;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable;
+import org.opensearch.index.remote.RemoteStoreEnums;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_TABLE;
+import static org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64;
+import static org.opensearch.index.remote.RemoteStoreEnums.PathType.HASHED_PREFIX;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteRoutingTableBlobStoreTests extends OpenSearchTestCase {
+
+    private RemoteRoutingTableBlobStore<IndexRoutingTable, RemoteIndexRoutingTable> remoteIndexRoutingTableStore;
+    ClusterSettings clusterSettings;
+    ThreadPool threadPool;
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        BlobStoreTransferService blobStoreTransferService = mock(BlobStoreTransferService.class);
+        BlobStoreRepository blobStoreRepository = mock(BlobStoreRepository.class);
+        BlobPath blobPath = new BlobPath().add("base-path");
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+
+        threadPool = new TestThreadPool(getClass().getName());
+        this.remoteIndexRoutingTableStore = new RemoteRoutingTableBlobStore<>(
+            blobStoreTransferService,
+            blobStoreRepository,
+            "test-cluster",
+            threadPool,
+            ThreadPool.Names.REMOTE_STATE_READ,
+            clusterSettings
+        );
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+
+    }
+
+    public void testRemoteRoutingTablePathTypeSetting() {
+        // Assert the default is HASHED_PREFIX
+        assertEquals(HASHED_PREFIX.toString(), remoteIndexRoutingTableStore.getPathTypeSetting().toString());
+
+        Settings newSettings = Settings.builder()
+            .put("cluster.remote_store.routing_table.path_type", RemoteStoreEnums.PathType.FIXED.toString())
+            .build();
+        clusterSettings.applySettings(newSettings);
+        assertEquals(RemoteStoreEnums.PathType.FIXED.toString(), remoteIndexRoutingTableStore.getPathTypeSetting().toString());
+    }
+
+    public void testRemoteRoutingTableHashAlgoSetting() {
+        // Assert the default is FNV_1A_BASE64
+        assertEquals(FNV_1A_BASE64.toString(), remoteIndexRoutingTableStore.getPathHashAlgoSetting().toString());
+
+        Settings newSettings = Settings.builder()
+            .put("cluster.remote_store.routing_table.path_hash_algo", RemoteStoreEnums.PathHashAlgorithm.FNV_1A_COMPOSITE_1.toString())
+            .build();
+        clusterSettings.applySettings(newSettings);
+        assertEquals(
+            RemoteStoreEnums.PathHashAlgorithm.FNV_1A_COMPOSITE_1.toString(),
+            remoteIndexRoutingTableStore.getPathHashAlgoSetting().toString()
+        );
+    }
+
+    public void testGetBlobPathForUpload() {
+
+        Index index = new Index("test-idx", "index-uuid");
+        Settings idxSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, index.getUUID())
+            .build();
+
+        IndexMetadata indexMetadata = new IndexMetadata.Builder(index.getName()).settings(idxSettings)
+            .numberOfShards(1)
+            .numberOfReplicas(0)
+            .build();
+
+        IndexRoutingTable indexRoutingTable = new IndexRoutingTable.Builder(index).initializeAsNew(indexMetadata).build();
+
+        RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+            indexRoutingTable,
+            "cluster-uuid",
+            new DeflateCompressor(),
+            2L,
+            3L
+        );
+        BlobPath blobPath = remoteIndexRoutingTableStore.getBlobPathForUpload(remoteObjectForUpload);
+        BlobPath expectedPath = HASHED_PREFIX.path(
+            RemoteStorePathStrategy.PathInput.builder()
+                .basePath(
+                    new BlobPath().add("base-path")
+                        .add(RemoteClusterStateUtils.encodeString("test-cluster"))
+                        .add(CLUSTER_STATE_PATH_TOKEN)
+                        .add("cluster-uuid")
+                        .add(INDEX_ROUTING_TABLE)
+                )
+                .indexUUID(index.getUUID())
+                .build(),
+            FNV_1A_BASE64
+        );
+        assertEquals(expectedPath, blobPath);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/routingtable/IndexRoutingTableHeaderTests.java b/server/src/test/java/org/opensearch/gateway/remote/routingtable/IndexRoutingTableHeaderTests.java
deleted file mode 100644
index a3f0ac36a40f1..0000000000000
--- a/server/src/test/java/org/opensearch/gateway/remote/routingtable/IndexRoutingTableHeaderTests.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.gateway.remote.routingtable;
-
-import org.opensearch.common.io.stream.BytesStreamOutput;
-import org.opensearch.core.common.io.stream.BytesStreamInput;
-import org.opensearch.test.OpenSearchTestCase;
-
-import java.io.IOException;
-
-public class IndexRoutingTableHeaderTests extends OpenSearchTestCase {
-
-    public void testIndexRoutingTableHeader() throws IOException {
-        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
-        IndexRoutingTableHeader header = new IndexRoutingTableHeader(indexName);
-        try (BytesStreamOutput out = new BytesStreamOutput()) {
-            header.writeTo(out);
-
-            BytesStreamInput in = new BytesStreamInput(out.bytes().toBytesRef().bytes);
-            IndexRoutingTableHeader headerRead = new IndexRoutingTableHeader(in);
-            assertEquals(indexName, headerRead.getIndexName());
-
-        }
-    }
-
-}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTableDiffTests.java b/server/src/test/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTableDiffTests.java
new file mode 100644
index 0000000000000..6ffa7fc5cded8
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTableDiffTests.java
@@ -0,0 +1,317 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.routingtable;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.Diff;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.RoutingTableIncrementalDiff;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_FILE;
+import static org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_METADATA_PREFIX;
+import static org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_PATH_TOKEN;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.nullValue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteIndexRoutingTableDiffTests extends OpenSearchTestCase {
+
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_PATH = "test-path";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final long STATE_VERSION = 3L;
+    private static final long STATE_TERM = 2L;
+    private String clusterUUID;
+    private BlobStoreRepository blobStoreRepository;
+    private BlobStoreTransferService blobStoreTransferService;
+    private ClusterSettings clusterSettings;
+    private Compressor compressor;
+
+    private String clusterName;
+    private NamedWriteableRegistry namedWriteableRegistry;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        this.clusterUUID = "test-cluster-uuid";
+        this.blobStoreTransferService = mock(BlobStoreTransferService.class);
+        this.blobStoreRepository = mock(BlobStoreRepository.class);
+        BlobPath blobPath = new BlobPath().add("/path");
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+        when(blobStoreRepository.getCompressor()).thenReturn(new DeflateCompressor());
+        compressor = new NoneCompressor();
+        namedWriteableRegistry = writableRegistry();
+        this.clusterName = "test-cluster-name";
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testClusterUUID() {
+        Map<String, Diff<IndexRoutingTable>> diffs = new HashMap<>();
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+
+        IndexMetadata indexMetadata = IndexMetadata.builder(indexName)
+            .settings(settings(Version.CURRENT))
+            .numberOfShards(numberOfShards)
+            .numberOfReplicas(numberOfReplicas)
+            .build();
+
+        IndexRoutingTable indexRoutingTable = IndexRoutingTable.builder(indexMetadata.getIndex()).initializeAsNew(indexMetadata).build();
+
+        diffs.put(indexName, indexRoutingTable.diff(indexRoutingTable));
+
+        RoutingTableIncrementalDiff routingTableIncrementalDiff = new RoutingTableIncrementalDiff(diffs);
+
+        RemoteRoutingTableDiff remoteDiffForUpload = new RemoteRoutingTableDiff(
+            routingTableIncrementalDiff,
+            clusterUUID,
+            compressor,
+            STATE_TERM,
+            STATE_VERSION
+        );
+        assertEquals(remoteDiffForUpload.clusterUUID(), clusterUUID);
+
+        RemoteRoutingTableDiff remoteDiffForDownload = new RemoteRoutingTableDiff(TEST_BLOB_NAME, clusterUUID, compressor);
+        assertEquals(remoteDiffForDownload.clusterUUID(), clusterUUID);
+    }
+
+    public void testFullBlobName() {
+        Map<String, Diff<IndexRoutingTable>> diffs = new HashMap<>();
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+
+        IndexMetadata indexMetadata = IndexMetadata.builder(indexName)
+            .settings(settings(Version.CURRENT))
+            .numberOfShards(numberOfShards)
+            .numberOfReplicas(numberOfReplicas)
+            .build();
+
+        IndexRoutingTable indexRoutingTable = IndexRoutingTable.builder(indexMetadata.getIndex()).initializeAsNew(indexMetadata).build();
+
+        diffs.put(indexName, indexRoutingTable.diff(indexRoutingTable));
+        RoutingTableIncrementalDiff routingTableIncrementalDiff = new RoutingTableIncrementalDiff(diffs);
+
+        RemoteRoutingTableDiff remoteDiffForUpload = new RemoteRoutingTableDiff(
+            routingTableIncrementalDiff,
+            clusterUUID,
+            compressor,
+            STATE_TERM,
+            STATE_VERSION
+        );
+        assertThat(remoteDiffForUpload.getFullBlobName(), nullValue());
+
+        RemoteRoutingTableDiff remoteDiffForDownload = new RemoteRoutingTableDiff(TEST_BLOB_NAME, clusterUUID, compressor);
+        assertThat(remoteDiffForDownload.getFullBlobName(), is(TEST_BLOB_NAME));
+    }
+
+    public void testBlobFileName() {
+        Map<String, Diff<IndexRoutingTable>> diffs = new HashMap<>();
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+
+        IndexMetadata indexMetadata = IndexMetadata.builder(indexName)
+            .settings(settings(Version.CURRENT))
+            .numberOfShards(numberOfShards)
+            .numberOfReplicas(numberOfReplicas)
+            .build();
+
+        IndexRoutingTable indexRoutingTable = IndexRoutingTable.builder(indexMetadata.getIndex()).initializeAsNew(indexMetadata).build();
+
+        diffs.put(indexName, indexRoutingTable.diff(indexRoutingTable));
+        RoutingTableIncrementalDiff routingTableIncrementalDiff = new RoutingTableIncrementalDiff(diffs);
+
+        RemoteRoutingTableDiff remoteDiffForUpload = new RemoteRoutingTableDiff(
+            routingTableIncrementalDiff,
+            clusterUUID,
+            compressor,
+            STATE_TERM,
+            STATE_VERSION
+        );
+        assertThat(remoteDiffForUpload.getBlobFileName(), nullValue());
+
+        RemoteRoutingTableDiff remoteDiffForDownload = new RemoteRoutingTableDiff(TEST_BLOB_NAME, clusterUUID, compressor);
+        assertThat(remoteDiffForDownload.getBlobFileName(), is(TEST_BLOB_FILE_NAME));
+    }
+
+    public void testBlobPathParameters() {
+        Map<String, Diff<IndexRoutingTable>> diffs = new HashMap<>();
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+
+        IndexMetadata indexMetadata = IndexMetadata.builder(indexName)
+            .settings(settings(Version.CURRENT))
+            .numberOfShards(numberOfShards)
+            .numberOfReplicas(numberOfReplicas)
+            .build();
+
+        IndexRoutingTable indexRoutingTable = IndexRoutingTable.builder(indexMetadata.getIndex()).initializeAsNew(indexMetadata).build();
+
+        diffs.put(indexName, indexRoutingTable.diff(indexRoutingTable));
+        RoutingTableIncrementalDiff routingTableIncrementalDiff = new RoutingTableIncrementalDiff(diffs);
+
+        RemoteRoutingTableDiff remoteDiffForUpload = new RemoteRoutingTableDiff(
+            routingTableIncrementalDiff,
+            clusterUUID,
+            compressor,
+            STATE_TERM,
+            STATE_VERSION
+        );
+        assertThat(remoteDiffForUpload.getBlobFileName(), nullValue());
+
+        BlobPathParameters params = remoteDiffForUpload.getBlobPathParameters();
+        assertThat(params.getPathTokens(), is(List.of(ROUTING_TABLE_DIFF_PATH_TOKEN)));
+        String expectedPrefix = ROUTING_TABLE_DIFF_METADATA_PREFIX;
+        assertThat(params.getFilePrefix(), is(expectedPrefix));
+    }
+
+    public void testGenerateBlobFileName() {
+        Map<String, Diff<IndexRoutingTable>> diffs = new HashMap<>();
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+
+        IndexMetadata indexMetadata = IndexMetadata.builder(indexName)
+            .settings(settings(Version.CURRENT))
+            .numberOfShards(numberOfShards)
+            .numberOfReplicas(numberOfReplicas)
+            .build();
+
+        IndexRoutingTable indexRoutingTable = IndexRoutingTable.builder(indexMetadata.getIndex()).initializeAsNew(indexMetadata).build();
+
+        diffs.put(indexName, indexRoutingTable.diff(indexRoutingTable));
+        RoutingTableIncrementalDiff routingTableIncrementalDiff = new RoutingTableIncrementalDiff(diffs);
+
+        RemoteRoutingTableDiff remoteDiffForUpload = new RemoteRoutingTableDiff(
+            routingTableIncrementalDiff,
+            clusterUUID,
+            compressor,
+            STATE_TERM,
+            STATE_VERSION
+        );
+
+        String blobFileName = remoteDiffForUpload.generateBlobFileName();
+        String[] nameTokens = blobFileName.split("__");
+        assertEquals(ROUTING_TABLE_DIFF_METADATA_PREFIX, nameTokens[0]);
+        assertEquals(RemoteStoreUtils.invertLong(STATE_TERM), nameTokens[1]);
+        assertEquals(RemoteStoreUtils.invertLong(STATE_VERSION), nameTokens[2]);
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[3]), lessThanOrEqualTo(System.currentTimeMillis()));
+    }
+
+    public void testGetUploadedMetadata() throws IOException {
+        Map<String, Diff<IndexRoutingTable>> diffs = new HashMap<>();
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+
+        IndexMetadata indexMetadata = IndexMetadata.builder(indexName)
+            .settings(settings(Version.CURRENT))
+            .numberOfShards(numberOfShards)
+            .numberOfReplicas(numberOfReplicas)
+            .build();
+
+        IndexRoutingTable indexRoutingTable = IndexRoutingTable.builder(indexMetadata.getIndex()).initializeAsNew(indexMetadata).build();
+
+        diffs.put(indexName, indexRoutingTable.diff(indexRoutingTable));
+        RoutingTableIncrementalDiff routingTableIncrementalDiff = new RoutingTableIncrementalDiff(diffs);
+
+        RemoteRoutingTableDiff remoteDiffForUpload = new RemoteRoutingTableDiff(
+            routingTableIncrementalDiff,
+            clusterUUID,
+            compressor,
+            STATE_TERM,
+            STATE_VERSION
+        );
+
+        remoteDiffForUpload.setFullBlobName(new BlobPath().add(TEST_BLOB_PATH));
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadataAttribute = remoteDiffForUpload.getUploadedMetadata();
+        assertEquals(ROUTING_TABLE_DIFF_FILE, uploadedMetadataAttribute.getComponent());
+    }
+
+    public void testStreamOperations() throws IOException {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder(indexName)
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(numberOfShards)
+                    .numberOfReplicas(numberOfReplicas)
+            )
+            .build();
+
+        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+        Map<String, Diff<IndexRoutingTable>> diffs = new HashMap<>();
+
+        initialRoutingTable.getIndicesRouting().values().forEach(indexRoutingTable -> {
+            diffs.put(indexName, indexRoutingTable.diff(indexRoutingTable));
+            RoutingTableIncrementalDiff routingTableIncrementalDiff = new RoutingTableIncrementalDiff(diffs);
+
+            RemoteRoutingTableDiff remoteDiffForUpload = new RemoteRoutingTableDiff(
+                routingTableIncrementalDiff,
+                clusterUUID,
+                compressor,
+                STATE_TERM,
+                STATE_VERSION
+            );
+
+            assertThrows(AssertionError.class, remoteDiffForUpload::getUploadedMetadata);
+
+            try (InputStream inputStream = remoteDiffForUpload.serialize()) {
+                remoteDiffForUpload.setFullBlobName(BlobPath.cleanPath());
+                assertThat(inputStream.available(), greaterThan(0));
+
+                routingTableIncrementalDiff = remoteDiffForUpload.deserialize(inputStream);
+                assertEquals(remoteDiffForUpload.getDiffs().size(), routingTableIncrementalDiff.getDiffs().size());
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTableTests.java b/server/src/test/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTableTests.java
index 72066d8afb45b..29d4ffa978851 100644
--- a/server/src/test/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTableTests.java
+++ b/server/src/test/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTableTests.java
@@ -13,16 +13,136 @@
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.routing.IndexRoutingTable;
 import org.opensearch.cluster.routing.RoutingTable;
-import org.opensearch.cluster.routing.ShardRoutingState;
-import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
 import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
 
 import java.io.IOException;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_FILE;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_METADATA_PREFIX;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.nullValue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 public class RemoteIndexRoutingTableTests extends OpenSearchTestCase {
 
-    public void testRoutingTableInput() {
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_PATH = "test-path";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final String INDEX_ROUTING_TABLE_TYPE = "test-index-routing-table";
+    private static final long STATE_VERSION = 3L;
+    private static final long STATE_TERM = 2L;
+    private String clusterUUID;
+    private BlobStoreTransferService blobStoreTransferService;
+    private BlobStoreRepository blobStoreRepository;
+    private String clusterName;
+    private ClusterSettings clusterSettings;
+    private Compressor compressor;
+    private NamedWriteableRegistry namedWriteableRegistry;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        this.clusterUUID = "test-cluster-uuid";
+        this.blobStoreTransferService = mock(BlobStoreTransferService.class);
+        this.blobStoreRepository = mock(BlobStoreRepository.class);
+        BlobPath blobPath = new BlobPath().add("/path");
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+        when(blobStoreRepository.getCompressor()).thenReturn(new DeflateCompressor());
+        compressor = new NoneCompressor();
+        namedWriteableRegistry = writableRegistry();
+        this.clusterName = "test-cluster-name";
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testClusterUUID() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder(indexName)
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(numberOfShards)
+                    .numberOfReplicas(numberOfReplicas)
+            )
+            .build();
+
+        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+
+        initialRoutingTable.getIndicesRouting().values().forEach(indexRoutingTable -> {
+            RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+                indexRoutingTable,
+                clusterUUID,
+                compressor,
+                STATE_TERM,
+                STATE_VERSION
+            );
+            assertEquals(remoteObjectForUpload.clusterUUID(), clusterUUID);
+
+            RemoteIndexRoutingTable remoteObjectForDownload = new RemoteIndexRoutingTable(TEST_BLOB_NAME, clusterUUID, compressor);
+            assertEquals(remoteObjectForDownload.clusterUUID(), clusterUUID);
+        });
+    }
+
+    public void testFullBlobName() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder(indexName)
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(numberOfShards)
+                    .numberOfReplicas(numberOfReplicas)
+            )
+            .build();
+
+        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+
+        initialRoutingTable.getIndicesRouting().values().forEach(indexRoutingTable -> {
+            RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+                indexRoutingTable,
+                clusterUUID,
+                compressor,
+                STATE_TERM,
+                STATE_VERSION
+            );
+            assertThat(remoteObjectForUpload.getFullBlobName(), nullValue());
+
+            RemoteIndexRoutingTable remoteObjectForDownload = new RemoteIndexRoutingTable(TEST_BLOB_NAME, clusterUUID, compressor);
+            assertThat(remoteObjectForDownload.getFullBlobName(), is(TEST_BLOB_NAME));
+        });
+    }
+
+    public void testBlobFileName() {
         String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
         int numberOfShards = randomIntBetween(1, 10);
         int numberOfReplicas = randomIntBetween(1, 10);
@@ -37,51 +157,164 @@ public void testRoutingTableInput() {
 
         RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
 
-        initialRoutingTable.getIndicesRouting().values().forEach(indexShardRoutingTables -> {
-            RemoteIndexRoutingTable indexRouting = new RemoteIndexRoutingTable(indexShardRoutingTables);
-            try (BytesStreamOutput streamOutput = new BytesStreamOutput();) {
-                indexRouting.writeTo(streamOutput);
-                RemoteIndexRoutingTable remoteIndexRoutingTable = new RemoteIndexRoutingTable(
-                    streamOutput.bytes().streamInput(),
-                    metadata.index(indexName).getIndex()
-                );
-                IndexRoutingTable indexRoutingTable = remoteIndexRoutingTable.getIndexRoutingTable();
-                assertEquals(numberOfShards, indexRoutingTable.getShards().size());
-                assertEquals(metadata.index(indexName).getIndex(), indexRoutingTable.getIndex());
-                assertEquals(
-                    numberOfShards * (1 + numberOfReplicas),
-                    indexRoutingTable.shardsWithState(ShardRoutingState.UNASSIGNED).size()
-                );
+        initialRoutingTable.getIndicesRouting().values().forEach(indexRoutingTable -> {
+            RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+                indexRoutingTable,
+                clusterUUID,
+                compressor,
+                STATE_TERM,
+                STATE_VERSION
+            );
+            assertThat(remoteObjectForUpload.getBlobFileName(), nullValue());
+
+            RemoteIndexRoutingTable remoteObjectForDownload = new RemoteIndexRoutingTable(TEST_BLOB_NAME, clusterUUID, compressor);
+            assertThat(remoteObjectForDownload.getBlobFileName(), is(TEST_BLOB_FILE_NAME));
+        });
+    }
+
+    public void testBlobPathTokens() {
+        String uploadedFile = "user/local/opensearch/routingTable";
+        RemoteIndexRoutingTable remoteObjectForDownload = new RemoteIndexRoutingTable(uploadedFile, clusterUUID, compressor);
+        assertThat(remoteObjectForDownload.getBlobPathTokens(), is(new String[] { "user", "local", "opensearch", "routingTable" }));
+    }
+
+    public void testBlobPathParameters() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder(indexName)
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(numberOfShards)
+                    .numberOfReplicas(numberOfReplicas)
+            )
+            .build();
+
+        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+
+        initialRoutingTable.getIndicesRouting().values().forEach(indexRoutingTable -> {
+            RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+                indexRoutingTable,
+                clusterUUID,
+                compressor,
+                STATE_TERM,
+                STATE_VERSION
+            );
+            assertThat(remoteObjectForUpload.getBlobFileName(), nullValue());
+
+            BlobPathParameters params = remoteObjectForUpload.getBlobPathParameters();
+            assertThat(params.getPathTokens(), is(List.of(indexRoutingTable.getIndex().getUUID())));
+            String expectedPrefix = INDEX_ROUTING_FILE;
+            assertThat(params.getFilePrefix(), is(expectedPrefix));
+        });
+    }
+
+    public void testGenerateBlobFileName() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder(indexName)
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(numberOfShards)
+                    .numberOfReplicas(numberOfReplicas)
+            )
+            .build();
+
+        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+
+        initialRoutingTable.getIndicesRouting().values().forEach(indexRoutingTable -> {
+            RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+                indexRoutingTable,
+                clusterUUID,
+                compressor,
+                STATE_TERM,
+                STATE_VERSION
+            );
+
+            String blobFileName = remoteObjectForUpload.generateBlobFileName();
+            String[] nameTokens = blobFileName.split(RemoteClusterStateUtils.DELIMITER);
+            assertEquals(nameTokens[0], INDEX_ROUTING_FILE);
+            assertEquals(nameTokens[1], RemoteStoreUtils.invertLong(STATE_TERM));
+            assertEquals(nameTokens[2], RemoteStoreUtils.invertLong(STATE_VERSION));
+            assertThat(RemoteStoreUtils.invertLong(nameTokens[3]), lessThanOrEqualTo(System.currentTimeMillis()));
+        });
+    }
+
+    public void testGetUploadedMetadata() throws IOException {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder(indexName)
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(numberOfShards)
+                    .numberOfReplicas(numberOfReplicas)
+            )
+            .build();
+
+        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+
+        initialRoutingTable.getIndicesRouting().values().forEach(indexRoutingTable -> {
+            RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+                indexRoutingTable,
+                clusterUUID,
+                compressor,
+                STATE_TERM,
+                STATE_VERSION
+            );
+
+            assertThrows(AssertionError.class, remoteObjectForUpload::getUploadedMetadata);
+
+            try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+                remoteObjectForUpload.setFullBlobName(new BlobPath().add(TEST_BLOB_PATH));
+                ClusterMetadataManifest.UploadedMetadata uploadedMetadata = remoteObjectForUpload.getUploadedMetadata();
+                String expectedPrefix = INDEX_ROUTING_METADATA_PREFIX + indexRoutingTable.getIndex().getName();
+                assertThat(uploadedMetadata.getComponent(), is(expectedPrefix));
+                assertThat(uploadedMetadata.getUploadedFilename(), is(remoteObjectForUpload.getFullBlobName()));
             } catch (IOException e) {
                 throw new RuntimeException(e);
             }
         });
     }
 
-    public void testRoutingTableInputStreamWithInvalidIndex() {
+    public void testSerDe() throws IOException {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
         Metadata metadata = Metadata.builder()
-            .put(IndexMetadata.builder("test").settings(settings(Version.CURRENT)).numberOfShards(1).numberOfReplicas(1))
-            .put(IndexMetadata.builder("invalid-index").settings(settings(Version.CURRENT)).numberOfShards(1).numberOfReplicas(1))
+            .put(
+                IndexMetadata.builder(indexName)
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(numberOfShards)
+                    .numberOfReplicas(numberOfReplicas)
+            )
             .build();
 
-        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index("test")).build();
-        AtomicInteger assertionError = new AtomicInteger();
-        initialRoutingTable.getIndicesRouting().values().forEach(indexShardRoutingTables -> {
-            RemoteIndexRoutingTable indexRouting = new RemoteIndexRoutingTable(indexShardRoutingTables);
-            try (BytesStreamOutput streamOutput = new BytesStreamOutput()) {
-                indexRouting.writeTo(streamOutput);
-                RemoteIndexRoutingTable remoteIndexRoutingTable = new RemoteIndexRoutingTable(
-                    streamOutput.bytes().streamInput(),
-                    metadata.index("invalid-index").getIndex()
-                );
-            } catch (AssertionError e) {
-                assertionError.getAndIncrement();
+        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+
+        initialRoutingTable.getIndicesRouting().values().forEach(indexRoutingTable -> {
+            RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+                indexRoutingTable,
+                clusterUUID,
+                compressor,
+                STATE_TERM,
+                STATE_VERSION
+            );
+
+            assertThrows(AssertionError.class, remoteObjectForUpload::getUploadedMetadata);
+
+            try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+                remoteObjectForUpload.setFullBlobName(BlobPath.cleanPath());
+                assertThat(inputStream.available(), greaterThan(0));
+                IndexRoutingTable readIndexRoutingTable = remoteObjectForUpload.deserialize(inputStream);
+                assertEquals(readIndexRoutingTable, indexRoutingTable);
             } catch (IOException e) {
                 throw new RuntimeException(e);
             }
         });
-
-        assertEquals(1, assertionError.get());
     }
-
 }
diff --git a/server/src/test/java/org/opensearch/index/codec/composite/datacube/startree/StarTreeDocValuesFormatTests.java b/server/src/test/java/org/opensearch/index/codec/composite/datacube/startree/StarTreeDocValuesFormatTests.java
index 6c6d26656e4de..31df9a49bebfb 100644
--- a/server/src/test/java/org/opensearch/index/codec/composite/datacube/startree/StarTreeDocValuesFormatTests.java
+++ b/server/src/test/java/org/opensearch/index/codec/composite/datacube/startree/StarTreeDocValuesFormatTests.java
@@ -12,12 +12,7 @@
 import org.apache.logging.log4j.Logger;
 import org.apache.lucene.codecs.Codec;
 import org.apache.lucene.codecs.lucene99.Lucene99Codec;
-import org.apache.lucene.document.Document;
-import org.apache.lucene.document.SortedNumericDocValuesField;
-import org.apache.lucene.index.IndexWriterConfig;
-import org.apache.lucene.store.Directory;
 import org.apache.lucene.tests.index.BaseDocValuesFormatTestCase;
-import org.apache.lucene.tests.index.RandomIndexWriter;
 import org.apache.lucene.tests.util.LuceneTestCase;
 import org.opensearch.common.Rounding;
 import org.opensearch.index.codec.composite.Composite99Codec;
@@ -31,7 +26,6 @@
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.mapper.StarTreeMapper;
 
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -77,34 +71,4 @@ private static StarTreeField getStarTreeField(List<Rounding.DateTimeUnit> d1Cale
 
         return new StarTreeField("starTree", dims, metrics, config);
     }
-
-    public void testStarTreeDocValues() throws IOException {
-        Directory directory = newDirectory();
-        IndexWriterConfig conf = newIndexWriterConfig(null);
-        conf.setMergePolicy(newLogMergePolicy());
-        RandomIndexWriter iw = new RandomIndexWriter(random(), directory, conf);
-        Document doc = new Document();
-        doc.add(new SortedNumericDocValuesField("sndv", 1));
-        doc.add(new SortedNumericDocValuesField("dv", 1));
-        doc.add(new SortedNumericDocValuesField("field", 1));
-        iw.addDocument(doc);
-        doc.add(new SortedNumericDocValuesField("sndv", 1));
-        doc.add(new SortedNumericDocValuesField("dv", 1));
-        doc.add(new SortedNumericDocValuesField("field", 1));
-        iw.addDocument(doc);
-        iw.forceMerge(1);
-        doc.add(new SortedNumericDocValuesField("sndv", 2));
-        doc.add(new SortedNumericDocValuesField("dv", 2));
-        doc.add(new SortedNumericDocValuesField("field", 2));
-        iw.addDocument(doc);
-        doc.add(new SortedNumericDocValuesField("sndv", 2));
-        doc.add(new SortedNumericDocValuesField("dv", 2));
-        doc.add(new SortedNumericDocValuesField("field", 2));
-        iw.addDocument(doc);
-        iw.forceMerge(1);
-        iw.close();
-
-        // TODO : validate star tree structures that got created
-        directory.close();
-    }
 }
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/CountValueAggregatorTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/CountValueAggregatorTests.java
new file mode 100644
index 0000000000000..e30e203406a6c
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/CountValueAggregatorTests.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.numerictype.StarTreeNumericType;
+import org.opensearch.test.OpenSearchTestCase;
+
+public class CountValueAggregatorTests extends OpenSearchTestCase {
+    private final CountValueAggregator aggregator = new CountValueAggregator();
+
+    public void testGetAggregationType() {
+        assertEquals(MetricStat.COUNT.getTypeName(), aggregator.getAggregationType().getTypeName());
+    }
+
+    public void testGetAggregatedValueType() {
+        assertEquals(CountValueAggregator.VALUE_AGGREGATOR_TYPE, aggregator.getAggregatedValueType());
+    }
+
+    public void testGetInitialAggregatedValueForSegmentDocValue() {
+        assertEquals(1L, aggregator.getInitialAggregatedValueForSegmentDocValue(randomLong(), StarTreeNumericType.LONG), 0.0);
+    }
+
+    public void testMergeAggregatedValueAndSegmentValue() {
+        assertEquals(3L, aggregator.mergeAggregatedValueAndSegmentValue(2L, 3L, StarTreeNumericType.LONG), 0.0);
+    }
+
+    public void testMergeAggregatedValues() {
+        assertEquals(5L, aggregator.mergeAggregatedValues(2L, 3L), 0.0);
+    }
+
+    public void testGetInitialAggregatedValue() {
+        assertEquals(3L, aggregator.getInitialAggregatedValue(3L), 0.0);
+    }
+
+    public void testGetMaxAggregatedValueByteSize() {
+        assertEquals(Long.BYTES, aggregator.getMaxAggregatedValueByteSize());
+    }
+
+    public void testToLongValue() {
+        assertEquals(3L, aggregator.toLongValue(3L), 0.0);
+    }
+
+    public void testToStarTreeNumericTypeValue() {
+        assertEquals(3L, aggregator.toStarTreeNumericTypeValue(3L, StarTreeNumericType.LONG), 0.0);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MetricAggregatorInfoTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MetricAggregatorInfoTests.java
new file mode 100644
index 0000000000000..d08f637a3f0a9
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MetricAggregatorInfoTests.java
@@ -0,0 +1,123 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.fielddata.IndexNumericFieldData;
+import org.opensearch.test.OpenSearchTestCase;
+
+public class MetricAggregatorInfoTests extends OpenSearchTestCase {
+
+    public void testConstructor() {
+        MetricAggregatorInfo pair = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column1",
+            "star_tree_field",
+            IndexNumericFieldData.NumericType.DOUBLE,
+            null
+        );
+        assertEquals(MetricStat.SUM, pair.getMetricStat());
+        assertEquals("column1", pair.getField());
+    }
+
+    public void testCountStarConstructor() {
+        MetricAggregatorInfo pair = new MetricAggregatorInfo(
+            MetricStat.COUNT,
+            "anything",
+            "star_tree_field",
+            IndexNumericFieldData.NumericType.DOUBLE,
+            null
+        );
+        assertEquals(MetricStat.COUNT, pair.getMetricStat());
+        assertEquals("anything", pair.getField());
+    }
+
+    public void testToFieldName() {
+        MetricAggregatorInfo pair = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column2",
+            "star_tree_field",
+            IndexNumericFieldData.NumericType.DOUBLE,
+            null
+        );
+        assertEquals("star_tree_field_column2_sum", pair.toFieldName());
+    }
+
+    public void testEquals() {
+        MetricAggregatorInfo pair1 = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column1",
+            "star_tree_field",
+            IndexNumericFieldData.NumericType.DOUBLE,
+            null
+        );
+        MetricAggregatorInfo pair2 = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column1",
+            "star_tree_field",
+            IndexNumericFieldData.NumericType.DOUBLE,
+            null
+        );
+        assertEquals(pair1, pair2);
+        assertNotEquals(
+            pair1,
+            new MetricAggregatorInfo(MetricStat.COUNT, "column1", "star_tree_field", IndexNumericFieldData.NumericType.DOUBLE, null)
+        );
+        assertNotEquals(
+            pair1,
+            new MetricAggregatorInfo(MetricStat.SUM, "column2", "star_tree_field", IndexNumericFieldData.NumericType.DOUBLE, null)
+        );
+    }
+
+    public void testHashCode() {
+        MetricAggregatorInfo pair1 = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column1",
+            "star_tree_field",
+            IndexNumericFieldData.NumericType.DOUBLE,
+            null
+        );
+        MetricAggregatorInfo pair2 = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column1",
+            "star_tree_field",
+            IndexNumericFieldData.NumericType.DOUBLE,
+            null
+        );
+        assertEquals(pair1.hashCode(), pair2.hashCode());
+    }
+
+    public void testCompareTo() {
+        MetricAggregatorInfo pair1 = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column1",
+            "star_tree_field",
+            IndexNumericFieldData.NumericType.DOUBLE,
+            null
+        );
+        MetricAggregatorInfo pair2 = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column2",
+            "star_tree_field",
+            IndexNumericFieldData.NumericType.DOUBLE,
+            null
+        );
+        MetricAggregatorInfo pair3 = new MetricAggregatorInfo(
+            MetricStat.COUNT,
+            "column1",
+            "star_tree_field",
+            IndexNumericFieldData.NumericType.DOUBLE,
+            null
+        );
+        assertTrue(pair1.compareTo(pair2) < 0);
+        assertTrue(pair2.compareTo(pair1) > 0);
+        assertTrue(pair1.compareTo(pair3) > 0);
+        assertTrue(pair3.compareTo(pair1) < 0);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/SumValueAggregatorTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/SumValueAggregatorTests.java
new file mode 100644
index 0000000000000..3fb627e7cd434
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/SumValueAggregatorTests.java
@@ -0,0 +1,72 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.apache.lucene.util.NumericUtils;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.numerictype.StarTreeNumericType;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+public class SumValueAggregatorTests extends OpenSearchTestCase {
+
+    private SumValueAggregator aggregator;
+
+    @Before
+    public void setup() {
+        aggregator = new SumValueAggregator();
+    }
+
+    public void testGetAggregationType() {
+        assertEquals(MetricStat.SUM.getTypeName(), aggregator.getAggregationType().getTypeName());
+    }
+
+    public void testGetAggregatedValueType() {
+        assertEquals(SumValueAggregator.VALUE_AGGREGATOR_TYPE, aggregator.getAggregatedValueType());
+    }
+
+    public void testGetInitialAggregatedValueForSegmentDocValue() {
+        assertEquals(1.0, aggregator.getInitialAggregatedValueForSegmentDocValue(1L, StarTreeNumericType.LONG), 0.0);
+        assertThrows(
+            NullPointerException.class,
+            () -> aggregator.getInitialAggregatedValueForSegmentDocValue(null, StarTreeNumericType.DOUBLE)
+        );
+    }
+
+    public void testMergeAggregatedValueAndSegmentValue() {
+        aggregator.getInitialAggregatedValue(2.0);
+        assertEquals(5.0, aggregator.mergeAggregatedValueAndSegmentValue(2.0, 3L, StarTreeNumericType.LONG), 0.0);
+    }
+
+    public void testMergeAggregatedValueAndSegmentValue_nullSegmentDocValue() {
+        aggregator.getInitialAggregatedValue(2.0);
+        assertThrows(NullPointerException.class, () -> aggregator.mergeAggregatedValueAndSegmentValue(2.0, null, StarTreeNumericType.LONG));
+    }
+
+    public void testMergeAggregatedValues() {
+        aggregator.getInitialAggregatedValue(3.0);
+        assertEquals(5.0, aggregator.mergeAggregatedValues(2.0, 3.0), 0.0);
+    }
+
+    public void testGetInitialAggregatedValue() {
+        assertEquals(3.14, aggregator.getInitialAggregatedValue(3.14), 0.0);
+    }
+
+    public void testGetMaxAggregatedValueByteSize() {
+        assertEquals(Double.BYTES, aggregator.getMaxAggregatedValueByteSize());
+    }
+
+    public void testToLongValue() {
+        assertEquals(NumericUtils.doubleToSortableLong(3.14), aggregator.toLongValue(3.14), 0.0);
+    }
+
+    public void testToStarTreeNumericTypeValue() {
+        assertEquals(NumericUtils.sortableLongToDouble(3L), aggregator.toStarTreeNumericTypeValue(3L, StarTreeNumericType.DOUBLE), 0.0);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregatorFactoryTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregatorFactoryTests.java
new file mode 100644
index 0000000000000..ce61ab839cc61
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregatorFactoryTests.java
@@ -0,0 +1,27 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.numerictype.StarTreeNumericType;
+import org.opensearch.test.OpenSearchTestCase;
+
+public class ValueAggregatorFactoryTests extends OpenSearchTestCase {
+
+    public void testGetValueAggregatorForSumType() {
+        ValueAggregator aggregator = ValueAggregatorFactory.getValueAggregator(MetricStat.SUM);
+        assertNotNull(aggregator);
+        assertEquals(SumValueAggregator.class, aggregator.getClass());
+    }
+
+    public void testGetAggregatedValueTypeForSumType() {
+        StarTreeNumericType starTreeNumericType = ValueAggregatorFactory.getAggregatedValueType(MetricStat.SUM);
+        assertEquals(SumValueAggregator.VALUE_AGGREGATOR_TYPE, starTreeNumericType);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilderTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilderTests.java
new file mode 100644
index 0000000000000..b78130e72aba1
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilderTests.java
@@ -0,0 +1,216 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.codecs.lucene99.Lucene99Codec;
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.FieldInfos;
+import org.apache.lucene.index.IndexOptions;
+import org.apache.lucene.index.SegmentInfo;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.index.VectorEncoding;
+import org.apache.lucene.index.VectorSimilarityFunction;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.InfoStream;
+import org.apache.lucene.util.Version;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.NumericDimension;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeDocument;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.MetricAggregatorInfo;
+import org.opensearch.index.fielddata.IndexNumericFieldData;
+import org.opensearch.index.mapper.ContentPath;
+import org.opensearch.index.mapper.DocumentMapper;
+import org.opensearch.index.mapper.Mapper;
+import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.mapper.MappingLookup;
+import org.opensearch.index.mapper.NumberFieldMapper;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.BeforeClass;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class BaseStarTreeBuilderTests extends OpenSearchTestCase {
+
+    private static BaseStarTreeBuilder builder;
+    private static MapperService mapperService;
+    private static List<Dimension> dimensionsOrder;
+    private static List<String> fields = List.of(
+        "field1",
+        "field2",
+        "field3",
+        "field4",
+        "field5",
+        "field6",
+        "field7",
+        "field8",
+        "field9",
+        "field10"
+    );
+    private static List<Metric> metrics;
+    private static Directory directory;
+    private static FieldInfo[] fieldsInfo;
+    private static SegmentWriteState state;
+    private static StarTreeField starTreeField;
+
+    @BeforeClass
+    public static void setup() throws IOException {
+
+        dimensionsOrder = List.of(
+            new NumericDimension("field1"),
+            new NumericDimension("field3"),
+            new NumericDimension("field5"),
+            new NumericDimension("field8")
+        );
+        metrics = List.of(new Metric("field2", List.of(MetricStat.SUM)), new Metric("field4", List.of(MetricStat.SUM)));
+
+        starTreeField = new StarTreeField(
+            "test",
+            dimensionsOrder,
+            metrics,
+            new StarTreeFieldConfiguration(1, Set.of("field8"), StarTreeFieldConfiguration.StarTreeBuildMode.ON_HEAP)
+        );
+
+        DocValuesProducer docValuesProducer = mock(DocValuesProducer.class);
+        directory = newFSDirectory(createTempDir());
+        SegmentInfo segmentInfo = new SegmentInfo(
+            directory,
+            Version.LATEST,
+            Version.LUCENE_9_11_0,
+            "test_segment",
+            5,
+            false,
+            false,
+            new Lucene99Codec(),
+            new HashMap<>(),
+            UUID.randomUUID().toString().substring(0, 16).getBytes(StandardCharsets.UTF_8),
+            new HashMap<>(),
+            null
+        );
+
+        fieldsInfo = new FieldInfo[fields.size()];
+        Map<String, DocValuesProducer> fieldProducerMap = new HashMap<>();
+        for (int i = 0; i < fieldsInfo.length; i++) {
+            fieldsInfo[i] = new FieldInfo(
+                fields.get(i),
+                i,
+                false,
+                false,
+                true,
+                IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS,
+                DocValuesType.SORTED_NUMERIC,
+                -1,
+                Collections.emptyMap(),
+                0,
+                0,
+                0,
+                0,
+                VectorEncoding.FLOAT32,
+                VectorSimilarityFunction.EUCLIDEAN,
+                false,
+                false
+            );
+            fieldProducerMap.put(fields.get(i), docValuesProducer);
+        }
+        FieldInfos fieldInfos = new FieldInfos(fieldsInfo);
+        state = new SegmentWriteState(InfoStream.getDefault(), segmentInfo.dir, segmentInfo, fieldInfos, null, newIOContext(random()));
+
+        mapperService = mock(MapperService.class);
+        DocumentMapper documentMapper = mock(DocumentMapper.class);
+        when(mapperService.documentMapper()).thenReturn(documentMapper);
+        Settings settings = Settings.builder().put(settings(org.opensearch.Version.CURRENT).build()).build();
+        NumberFieldMapper numberFieldMapper1 = new NumberFieldMapper.Builder("field2", NumberFieldMapper.NumberType.DOUBLE, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper2 = new NumberFieldMapper.Builder("field4", NumberFieldMapper.NumberType.DOUBLE, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        MappingLookup fieldMappers = new MappingLookup(
+            Set.of(numberFieldMapper1, numberFieldMapper2),
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0,
+            null
+        );
+        when(documentMapper.mappers()).thenReturn(fieldMappers);
+
+        builder = new BaseStarTreeBuilder(starTreeField, fieldProducerMap, state, mapperService) {
+            @Override
+            public void appendStarTreeDocument(StarTreeDocument starTreeDocument) throws IOException {}
+
+            @Override
+            public StarTreeDocument getStarTreeDocument(int docId) throws IOException {
+                return null;
+            }
+
+            @Override
+            public List<StarTreeDocument> getStarTreeDocuments() {
+                return List.of();
+            }
+
+            @Override
+            public Long getDimensionValue(int docId, int dimensionId) throws IOException {
+                return 0L;
+            }
+
+            @Override
+            public Iterator<StarTreeDocument> sortAndAggregateStarTreeDocuments() throws IOException {
+                return null;
+            }
+
+            @Override
+            public Iterator<StarTreeDocument> generateStarTreeDocumentsForStarNode(int startDocId, int endDocId, int dimensionId)
+                throws IOException {
+                return null;
+            }
+        };
+    }
+
+    public void test_generateMetricAggregatorInfos() throws IOException {
+        List<MetricAggregatorInfo> metricAggregatorInfos = builder.generateMetricAggregatorInfos(mapperService, state);
+        List<MetricAggregatorInfo> expectedMetricAggregatorInfos = List.of(
+            new MetricAggregatorInfo(MetricStat.SUM, "field2", starTreeField.getName(), IndexNumericFieldData.NumericType.DOUBLE, null),
+            new MetricAggregatorInfo(MetricStat.SUM, "field4", starTreeField.getName(), IndexNumericFieldData.NumericType.DOUBLE, null)
+        );
+        assertEquals(metricAggregatorInfos, expectedMetricAggregatorInfos);
+    }
+
+    public void test_reduceStarTreeDocuments() {
+        StarTreeDocument starTreeDocument1 = new StarTreeDocument(new Long[] { 1L, 3L, 5L, 8L }, new Double[] { 4.0, 8.0 });
+        StarTreeDocument starTreeDocument2 = new StarTreeDocument(new Long[] { 1L, 3L, 5L, 8L }, new Double[] { 10.0, 6.0 });
+
+        StarTreeDocument expectedeMergedStarTreeDocument = new StarTreeDocument(new Long[] { 1L, 3L, 5L, 8L }, new Double[] { 14.0, 14.0 });
+        StarTreeDocument mergedStarTreeDocument = builder.reduceStarTreeDocuments(null, starTreeDocument1);
+        StarTreeDocument resultStarTreeDocument = builder.reduceStarTreeDocuments(mergedStarTreeDocument, starTreeDocument2);
+
+        assertEquals(resultStarTreeDocument.metrics[0], expectedeMergedStarTreeDocument.metrics[0]);
+        assertEquals(resultStarTreeDocument.metrics[1], expectedeMergedStarTreeDocument.metrics[1]);
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+        directory.close();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilderTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilderTests.java
new file mode 100644
index 0000000000000..4e107e78d27be
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilderTests.java
@@ -0,0 +1,706 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.codecs.lucene99.Lucene99Codec;
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.FieldInfos;
+import org.apache.lucene.index.IndexOptions;
+import org.apache.lucene.index.SegmentInfo;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.index.VectorEncoding;
+import org.apache.lucene.index.VectorSimilarityFunction;
+import org.apache.lucene.sandbox.document.HalfFloatPoint;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.InfoStream;
+import org.apache.lucene.util.NumericUtils;
+import org.apache.lucene.util.Version;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.NumericDimension;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeDocument;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.mapper.ContentPath;
+import org.opensearch.index.mapper.DocumentMapper;
+import org.opensearch.index.mapper.Mapper;
+import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.mapper.MappingLookup;
+import org.opensearch.index.mapper.NumberFieldMapper;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class OnHeapStarTreeBuilderTests extends OpenSearchTestCase {
+
+    private OnHeapStarTreeBuilder builder;
+    private MapperService mapperService;
+    private List<Dimension> dimensionsOrder;
+    private List<String> fields = List.of();
+    private List<Metric> metrics;
+    private Directory directory;
+    private FieldInfo[] fieldsInfo;
+    private StarTreeField compositeField;
+    private Map<String, DocValuesProducer> fieldProducerMap;
+    private SegmentWriteState writeState;
+
+    @Before
+    public void setup() throws IOException {
+        fields = List.of("field1", "field2", "field3", "field4", "field5", "field6", "field7", "field8", "field9", "field10");
+
+        dimensionsOrder = List.of(
+            new NumericDimension("field1"),
+            new NumericDimension("field3"),
+            new NumericDimension("field5"),
+            new NumericDimension("field8")
+        );
+        metrics = List.of(
+            new Metric("field2", List.of(MetricStat.SUM)),
+            new Metric("field4", List.of(MetricStat.SUM)),
+            new Metric("field6", List.of(MetricStat.COUNT))
+        );
+
+        DocValuesProducer docValuesProducer = mock(DocValuesProducer.class);
+
+        compositeField = new StarTreeField(
+            "test",
+            dimensionsOrder,
+            metrics,
+            new StarTreeFieldConfiguration(1, Set.of("field8"), StarTreeFieldConfiguration.StarTreeBuildMode.ON_HEAP)
+        );
+        directory = newFSDirectory(createTempDir());
+        SegmentInfo segmentInfo = new SegmentInfo(
+            directory,
+            Version.LATEST,
+            Version.LUCENE_9_11_0,
+            "test_segment",
+            5,
+            false,
+            false,
+            new Lucene99Codec(),
+            new HashMap<>(),
+            UUID.randomUUID().toString().substring(0, 16).getBytes(StandardCharsets.UTF_8),
+            new HashMap<>(),
+            null
+        );
+
+        fieldsInfo = new FieldInfo[fields.size()];
+        fieldProducerMap = new HashMap<>();
+        for (int i = 0; i < fieldsInfo.length; i++) {
+            fieldsInfo[i] = new FieldInfo(
+                fields.get(i),
+                i,
+                false,
+                false,
+                true,
+                IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS,
+                DocValuesType.SORTED_NUMERIC,
+                -1,
+                Collections.emptyMap(),
+                0,
+                0,
+                0,
+                0,
+                VectorEncoding.FLOAT32,
+                VectorSimilarityFunction.EUCLIDEAN,
+                false,
+                false
+            );
+            fieldProducerMap.put(fields.get(i), docValuesProducer);
+        }
+        FieldInfos fieldInfos = new FieldInfos(fieldsInfo);
+        writeState = new SegmentWriteState(InfoStream.getDefault(), segmentInfo.dir, segmentInfo, fieldInfos, null, newIOContext(random()));
+
+        mapperService = mock(MapperService.class);
+        DocumentMapper documentMapper = mock(DocumentMapper.class);
+        when(mapperService.documentMapper()).thenReturn(documentMapper);
+        Settings settings = Settings.builder().put(settings(org.opensearch.Version.CURRENT).build()).build();
+        NumberFieldMapper numberFieldMapper1 = new NumberFieldMapper.Builder("field2", NumberFieldMapper.NumberType.DOUBLE, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper2 = new NumberFieldMapper.Builder("field4", NumberFieldMapper.NumberType.DOUBLE, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper3 = new NumberFieldMapper.Builder("field6", NumberFieldMapper.NumberType.DOUBLE, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        MappingLookup fieldMappers = new MappingLookup(
+            Set.of(numberFieldMapper1, numberFieldMapper2, numberFieldMapper3),
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0,
+            null
+        );
+        when(documentMapper.mappers()).thenReturn(fieldMappers);
+        builder = new OnHeapStarTreeBuilder(compositeField, fieldProducerMap, writeState, mapperService);
+    }
+
+    public void test_sortAndAggregateStarTreeDocuments() throws IOException {
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Double[] { 12.0, 10.0, randomDouble() });
+        starTreeDocuments[1] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Double[] { 10.0, 6.0, randomDouble() });
+        starTreeDocuments[2] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Double[] { 14.0, 12.0, randomDouble() });
+        starTreeDocuments[3] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Double[] { 9.0, 4.0, randomDouble() });
+        starTreeDocuments[4] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Double[] { 11.0, 16.0, randomDouble() });
+
+        List<StarTreeDocument> inorderStarTreeDocuments = List.of(
+            new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Object[] { 21.0, 14.0, 2L }),
+            new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Object[] { 35.0, 34.0, 3L })
+        );
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = inorderStarTreeDocuments.iterator();
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            long metric2 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1]);
+            long metric3 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2]);
+            segmentStarTreeDocuments[i] = new StarTreeDocument(starTreeDocuments[i].dimensions, new Long[] { metric1, metric2, metric3 });
+        }
+
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateStarTreeDocuments(segmentStarTreeDocuments);
+        int numOfAggregatedDocuments = 0;
+        while (segmentStarTreeDocumentIterator.hasNext() && expectedStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = segmentStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.dimensions[3], resultStarTreeDocument.dimensions[3]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+            assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+            assertEquals(expectedStarTreeDocument.metrics[2], resultStarTreeDocument.metrics[2]);
+
+            numOfAggregatedDocuments++;
+        }
+
+        assertEquals(inorderStarTreeDocuments.size(), numOfAggregatedDocuments);
+
+    }
+
+    public void test_sortAndAggregateStarTreeDocuments_nullMetric() throws IOException {
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Double[] { 12.0, 10.0, randomDouble() });
+        starTreeDocuments[1] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Double[] { 10.0, 6.0, randomDouble() });
+        starTreeDocuments[2] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Double[] { 14.0, 12.0, randomDouble() });
+        starTreeDocuments[3] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Double[] { 9.0, 4.0, randomDouble() });
+        starTreeDocuments[4] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Double[] { 11.0, null, randomDouble() });
+        StarTreeDocument expectedStarTreeDocument = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Double[] { 21.0, 14.0, 2.0 });
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            Long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            Long metric2 = starTreeDocuments[i].metrics[1] != null
+                ? NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1])
+                : null;
+            Long metric3 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2]);
+            segmentStarTreeDocuments[i] = new StarTreeDocument(starTreeDocuments[i].dimensions, new Object[] { metric1, metric2, metric3 });
+        }
+
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateStarTreeDocuments(segmentStarTreeDocuments);
+
+        StarTreeDocument resultStarTreeDocument = segmentStarTreeDocumentIterator.next();
+        assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+        assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+        assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+        assertEquals(expectedStarTreeDocument.dimensions[3], resultStarTreeDocument.dimensions[3]);
+        assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+        assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+
+        assertThrows(
+            "Null metric should have resulted in IllegalStateException",
+            IllegalStateException.class,
+            segmentStarTreeDocumentIterator::next
+        );
+
+    }
+
+    public void test_sortAndAggregateStarTreeDocument_longMaxAndLongMinDimensions() throws IOException {
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(new Long[] { Long.MIN_VALUE, 4L, 3L, 4L }, new Double[] { 12.0, 10.0, randomDouble() });
+        starTreeDocuments[1] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, Long.MAX_VALUE }, new Double[] { 10.0, 6.0, randomDouble() });
+        starTreeDocuments[2] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, Long.MAX_VALUE }, new Double[] { 14.0, 12.0, randomDouble() });
+        starTreeDocuments[3] = new StarTreeDocument(new Long[] { Long.MIN_VALUE, 4L, 3L, 4L }, new Double[] { 9.0, 4.0, randomDouble() });
+        starTreeDocuments[4] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, Long.MAX_VALUE }, new Double[] { 11.0, 16.0, randomDouble() });
+
+        List<StarTreeDocument> inorderStarTreeDocuments = List.of(
+            new StarTreeDocument(new Long[] { Long.MIN_VALUE, 4L, 3L, 4L }, new Object[] { 21.0, 14.0, 2L }),
+            new StarTreeDocument(new Long[] { 3L, 4L, 2L, Long.MAX_VALUE }, new Object[] { 35.0, 34.0, 3L })
+        );
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = inorderStarTreeDocuments.iterator();
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            long metric2 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1]);
+            long metric3 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2]);
+            segmentStarTreeDocuments[i] = new StarTreeDocument(starTreeDocuments[i].dimensions, new Long[] { metric1, metric2, metric3 });
+        }
+
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateStarTreeDocuments(segmentStarTreeDocuments);
+        int numOfAggregatedDocuments = 0;
+        while (segmentStarTreeDocumentIterator.hasNext() && expectedStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = segmentStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.dimensions[3], resultStarTreeDocument.dimensions[3]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+            assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+            assertEquals(expectedStarTreeDocument.metrics[2], resultStarTreeDocument.metrics[2]);
+
+            numOfAggregatedDocuments++;
+        }
+
+        assertEquals(inorderStarTreeDocuments.size(), numOfAggregatedDocuments);
+
+    }
+
+    public void test_sortAndAggregateStarTreeDocument_DoubleMaxAndDoubleMinMetrics() throws IOException {
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Double[] { Double.MAX_VALUE, 10.0, randomDouble() });
+        starTreeDocuments[1] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Double[] { 10.0, 6.0, randomDouble() });
+        starTreeDocuments[2] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Double[] { 14.0, Double.MIN_VALUE, randomDouble() });
+        starTreeDocuments[3] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Double[] { 9.0, 4.0, randomDouble() });
+        starTreeDocuments[4] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Double[] { 11.0, 16.0, randomDouble() });
+
+        List<StarTreeDocument> inorderStarTreeDocuments = List.of(
+            new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Object[] { Double.MAX_VALUE + 9, 14.0, 2L }),
+            new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Object[] { 35.0, Double.MIN_VALUE + 22, 3L })
+        );
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = inorderStarTreeDocuments.iterator();
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            long metric2 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1]);
+            long metric3 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2]);
+            segmentStarTreeDocuments[i] = new StarTreeDocument(starTreeDocuments[i].dimensions, new Long[] { metric1, metric2, metric3 });
+        }
+
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateStarTreeDocuments(segmentStarTreeDocuments);
+        int numOfAggregatedDocuments = 0;
+        while (segmentStarTreeDocumentIterator.hasNext() && expectedStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = segmentStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.dimensions[3], resultStarTreeDocument.dimensions[3]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+            assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+            assertEquals(expectedStarTreeDocument.metrics[2], resultStarTreeDocument.metrics[2]);
+
+            numOfAggregatedDocuments++;
+        }
+
+        assertEquals(inorderStarTreeDocuments.size(), numOfAggregatedDocuments);
+
+    }
+
+    public void test_build_halfFloatMetrics() throws IOException {
+
+        mapperService = mock(MapperService.class);
+        DocumentMapper documentMapper = mock(DocumentMapper.class);
+        when(mapperService.documentMapper()).thenReturn(documentMapper);
+        Settings settings = Settings.builder().put(settings(org.opensearch.Version.CURRENT).build()).build();
+        NumberFieldMapper numberFieldMapper1 = new NumberFieldMapper.Builder("field2", NumberFieldMapper.NumberType.HALF_FLOAT, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper2 = new NumberFieldMapper.Builder("field4", NumberFieldMapper.NumberType.HALF_FLOAT, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper3 = new NumberFieldMapper.Builder("field6", NumberFieldMapper.NumberType.HALF_FLOAT, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        MappingLookup fieldMappers = new MappingLookup(
+            Set.of(numberFieldMapper1, numberFieldMapper2, numberFieldMapper3),
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0,
+            null
+        );
+        when(documentMapper.mappers()).thenReturn(fieldMappers);
+        builder = new OnHeapStarTreeBuilder(compositeField, fieldProducerMap, writeState, mapperService);
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(
+            new Long[] { 2L, 4L, 3L, 4L },
+            new HalfFloatPoint[] { new HalfFloatPoint("hf1", 12), new HalfFloatPoint("hf6", 10), new HalfFloatPoint("field6", 10) }
+        );
+        starTreeDocuments[1] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new HalfFloatPoint[] { new HalfFloatPoint("hf2", 10), new HalfFloatPoint("hf7", 6), new HalfFloatPoint("field6", 10) }
+        );
+        starTreeDocuments[2] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new HalfFloatPoint[] { new HalfFloatPoint("hf3", 14), new HalfFloatPoint("hf8", 12), new HalfFloatPoint("field6", 10) }
+        );
+        starTreeDocuments[3] = new StarTreeDocument(
+            new Long[] { 2L, 4L, 3L, 4L },
+            new HalfFloatPoint[] { new HalfFloatPoint("hf4", 9), new HalfFloatPoint("hf9", 4), new HalfFloatPoint("field6", 10) }
+        );
+        starTreeDocuments[4] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new HalfFloatPoint[] { new HalfFloatPoint("hf5", 11), new HalfFloatPoint("hf10", 16), new HalfFloatPoint("field6", 10) }
+        );
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = HalfFloatPoint.halfFloatToSortableShort(
+                ((HalfFloatPoint) starTreeDocuments[i].metrics[0]).numericValue().floatValue()
+            );
+            long metric2 = HalfFloatPoint.halfFloatToSortableShort(
+                ((HalfFloatPoint) starTreeDocuments[i].metrics[1]).numericValue().floatValue()
+            );
+            long metric3 = HalfFloatPoint.halfFloatToSortableShort(
+                ((HalfFloatPoint) starTreeDocuments[i].metrics[2]).numericValue().floatValue()
+            );
+            segmentStarTreeDocuments[i] = new StarTreeDocument(starTreeDocuments[i].dimensions, new Long[] { metric1, metric2, metric3 });
+        }
+
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateStarTreeDocuments(segmentStarTreeDocuments);
+        builder.build(segmentStarTreeDocumentIterator);
+
+        List<StarTreeDocument> resultStarTreeDocuments = builder.getStarTreeDocuments();
+        assertEquals(7, resultStarTreeDocuments.size());
+
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = getExpectedStarTreeDocumentIterator();
+        assertStarTreeDocuments(resultStarTreeDocuments, expectedStarTreeDocumentIterator);
+    }
+
+    public void test_build_floatMetrics() throws IOException {
+
+        mapperService = mock(MapperService.class);
+        DocumentMapper documentMapper = mock(DocumentMapper.class);
+        when(mapperService.documentMapper()).thenReturn(documentMapper);
+        Settings settings = Settings.builder().put(settings(org.opensearch.Version.CURRENT).build()).build();
+        NumberFieldMapper numberFieldMapper1 = new NumberFieldMapper.Builder("field2", NumberFieldMapper.NumberType.FLOAT, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper2 = new NumberFieldMapper.Builder("field4", NumberFieldMapper.NumberType.FLOAT, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper3 = new NumberFieldMapper.Builder("field6", NumberFieldMapper.NumberType.FLOAT, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        MappingLookup fieldMappers = new MappingLookup(
+            Set.of(numberFieldMapper1, numberFieldMapper2, numberFieldMapper3),
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0,
+            null
+        );
+        when(documentMapper.mappers()).thenReturn(fieldMappers);
+        builder = new OnHeapStarTreeBuilder(compositeField, fieldProducerMap, writeState, mapperService);
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Float[] { 12.0F, 10.0F, randomFloat() });
+        starTreeDocuments[1] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Float[] { 10.0F, 6.0F, randomFloat() });
+        starTreeDocuments[2] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Float[] { 14.0F, 12.0F, randomFloat() });
+        starTreeDocuments[3] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Float[] { 9.0F, 4.0F, randomFloat() });
+        starTreeDocuments[4] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Float[] { 11.0F, 16.0F, randomFloat() });
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.floatToSortableInt((Float) starTreeDocuments[i].metrics[0]);
+            long metric2 = NumericUtils.floatToSortableInt((Float) starTreeDocuments[i].metrics[1]);
+            long metric3 = NumericUtils.floatToSortableInt((Float) starTreeDocuments[i].metrics[2]);
+            segmentStarTreeDocuments[i] = new StarTreeDocument(starTreeDocuments[i].dimensions, new Long[] { metric1, metric2, metric3 });
+        }
+
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateStarTreeDocuments(segmentStarTreeDocuments);
+        builder.build(segmentStarTreeDocumentIterator);
+
+        List<StarTreeDocument> resultStarTreeDocuments = builder.getStarTreeDocuments();
+        assertEquals(7, resultStarTreeDocuments.size());
+
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = getExpectedStarTreeDocumentIterator();
+        assertStarTreeDocuments(resultStarTreeDocuments, expectedStarTreeDocumentIterator);
+    }
+
+    public void test_build_longMetrics() throws IOException {
+
+        mapperService = mock(MapperService.class);
+        DocumentMapper documentMapper = mock(DocumentMapper.class);
+        when(mapperService.documentMapper()).thenReturn(documentMapper);
+        Settings settings = Settings.builder().put(settings(org.opensearch.Version.CURRENT).build()).build();
+        NumberFieldMapper numberFieldMapper1 = new NumberFieldMapper.Builder("field2", NumberFieldMapper.NumberType.LONG, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper2 = new NumberFieldMapper.Builder("field4", NumberFieldMapper.NumberType.LONG, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper3 = new NumberFieldMapper.Builder("field6", NumberFieldMapper.NumberType.LONG, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        MappingLookup fieldMappers = new MappingLookup(
+            Set.of(numberFieldMapper1, numberFieldMapper2, numberFieldMapper3),
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0,
+            null
+        );
+        when(documentMapper.mappers()).thenReturn(fieldMappers);
+        builder = new OnHeapStarTreeBuilder(compositeField, fieldProducerMap, writeState, mapperService);
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Long[] { 12L, 10L, randomLong() });
+        starTreeDocuments[1] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Long[] { 10L, 6L, randomLong() });
+        starTreeDocuments[2] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Long[] { 14L, 12L, randomLong() });
+        starTreeDocuments[3] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Long[] { 9L, 4L, randomLong() });
+        starTreeDocuments[4] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Long[] { 11L, 16L, randomLong() });
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = (Long) starTreeDocuments[i].metrics[0];
+            long metric2 = (Long) starTreeDocuments[i].metrics[1];
+            long metric3 = (Long) starTreeDocuments[i].metrics[2];
+            segmentStarTreeDocuments[i] = new StarTreeDocument(starTreeDocuments[i].dimensions, new Long[] { metric1, metric2, metric3 });
+        }
+
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateStarTreeDocuments(segmentStarTreeDocuments);
+        builder.build(segmentStarTreeDocumentIterator);
+
+        List<StarTreeDocument> resultStarTreeDocuments = builder.getStarTreeDocuments();
+        assertEquals(7, resultStarTreeDocuments.size());
+
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = getExpectedStarTreeDocumentIterator();
+        assertStarTreeDocuments(resultStarTreeDocuments, expectedStarTreeDocumentIterator);
+    }
+
+    private static Iterator<StarTreeDocument> getExpectedStarTreeDocumentIterator() {
+        List<StarTreeDocument> expectedStarTreeDocuments = List.of(
+            new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Object[] { 21.0, 14.0, 2L }),
+            new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Object[] { 35.0, 34.0, 3L }),
+            new StarTreeDocument(new Long[] { -1L, 4L, 2L, 1L }, new Object[] { 35.0, 34.0, 3L }),
+            new StarTreeDocument(new Long[] { -1L, 4L, 3L, 4L }, new Object[] { 21.0, 14.0, 2L }),
+            new StarTreeDocument(new Long[] { -1L, 4L, -1L, 1L }, new Object[] { 35.0, 34.0, 3L }),
+            new StarTreeDocument(new Long[] { -1L, 4L, -1L, 4L }, new Object[] { 21.0, 14.0, 2L }),
+            new StarTreeDocument(new Long[] { -1L, 4L, -1L, -1L }, new Object[] { 56.0, 48.0, 5L })
+        );
+        return expectedStarTreeDocuments.iterator();
+    }
+
+    public void test_build() throws IOException {
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Double[] { 12.0, 10.0, randomDouble() });
+        starTreeDocuments[1] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Double[] { 10.0, 6.0, randomDouble() });
+        starTreeDocuments[2] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Double[] { 14.0, 12.0, randomDouble() });
+        starTreeDocuments[3] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Double[] { 9.0, 4.0, randomDouble() });
+        starTreeDocuments[4] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Double[] { 11.0, 16.0, randomDouble() });
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            long metric2 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1]);
+            long metric3 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2]);
+            segmentStarTreeDocuments[i] = new StarTreeDocument(starTreeDocuments[i].dimensions, new Long[] { metric1, metric2, metric3 });
+        }
+
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateStarTreeDocuments(segmentStarTreeDocuments);
+        builder.build(segmentStarTreeDocumentIterator);
+
+        List<StarTreeDocument> resultStarTreeDocuments = builder.getStarTreeDocuments();
+        assertEquals(7, resultStarTreeDocuments.size());
+
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = getExpectedStarTreeDocumentIterator();
+        assertStarTreeDocuments(resultStarTreeDocuments, expectedStarTreeDocumentIterator);
+    }
+
+    private void assertStarTreeDocuments(
+        List<StarTreeDocument> resultStarTreeDocuments,
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator
+    ) {
+        Iterator<StarTreeDocument> resultStarTreeDocumentIterator = resultStarTreeDocuments.iterator();
+        while (resultStarTreeDocumentIterator.hasNext() && expectedStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = resultStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.dimensions[3], resultStarTreeDocument.dimensions[3]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+            assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+            assertEquals(expectedStarTreeDocument.metrics[2], resultStarTreeDocument.metrics[2]);
+        }
+    }
+
+    public void test_build_starTreeDataset() throws IOException {
+
+        fields = List.of("fieldC", "fieldB", "fieldL", "fieldI");
+
+        dimensionsOrder = List.of(new NumericDimension("fieldC"), new NumericDimension("fieldB"), new NumericDimension("fieldL"));
+        metrics = List.of(new Metric("fieldI", List.of(MetricStat.SUM)));
+
+        DocValuesProducer docValuesProducer = mock(DocValuesProducer.class);
+
+        compositeField = new StarTreeField(
+            "test",
+            dimensionsOrder,
+            metrics,
+            new StarTreeFieldConfiguration(1, Set.of(), StarTreeFieldConfiguration.StarTreeBuildMode.ON_HEAP)
+        );
+        SegmentInfo segmentInfo = new SegmentInfo(
+            directory,
+            Version.LATEST,
+            Version.LUCENE_9_11_0,
+            "test_segment",
+            7,
+            false,
+            false,
+            new Lucene99Codec(),
+            new HashMap<>(),
+            UUID.randomUUID().toString().substring(0, 16).getBytes(StandardCharsets.UTF_8),
+            new HashMap<>(),
+            null
+        );
+
+        fieldsInfo = new FieldInfo[fields.size()];
+        fieldProducerMap = new HashMap<>();
+        for (int i = 0; i < fieldsInfo.length; i++) {
+            fieldsInfo[i] = new FieldInfo(
+                fields.get(i),
+                i,
+                false,
+                false,
+                true,
+                IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS,
+                DocValuesType.SORTED_NUMERIC,
+                -1,
+                Collections.emptyMap(),
+                0,
+                0,
+                0,
+                0,
+                VectorEncoding.FLOAT32,
+                VectorSimilarityFunction.EUCLIDEAN,
+                false,
+                false
+            );
+            fieldProducerMap.put(fields.get(i), docValuesProducer);
+        }
+        FieldInfos fieldInfos = new FieldInfos(fieldsInfo);
+        writeState = new SegmentWriteState(InfoStream.getDefault(), segmentInfo.dir, segmentInfo, fieldInfos, null, newIOContext(random()));
+
+        mapperService = mock(MapperService.class);
+        DocumentMapper documentMapper = mock(DocumentMapper.class);
+        when(mapperService.documentMapper()).thenReturn(documentMapper);
+        Settings settings = Settings.builder().put(settings(org.opensearch.Version.CURRENT).build()).build();
+        NumberFieldMapper numberFieldMapper1 = new NumberFieldMapper.Builder("fieldI", NumberFieldMapper.NumberType.DOUBLE, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        MappingLookup fieldMappers = new MappingLookup(
+            Set.of(numberFieldMapper1),
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0,
+            null
+        );
+        when(documentMapper.mappers()).thenReturn(fieldMappers);
+        builder = new OnHeapStarTreeBuilder(compositeField, fieldProducerMap, writeState, mapperService);
+
+        int noOfStarTreeDocuments = 7;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        starTreeDocuments[0] = new StarTreeDocument(new Long[] { 1L, 11L, 21L }, new Double[] { 400.0 });
+        starTreeDocuments[1] = new StarTreeDocument(new Long[] { 1L, 12L, 22L }, new Double[] { 200.0 });
+        starTreeDocuments[2] = new StarTreeDocument(new Long[] { 2L, 13L, 23L }, new Double[] { 300.0 });
+        starTreeDocuments[3] = new StarTreeDocument(new Long[] { 2L, 13L, 21L }, new Double[] { 100.0 });
+        starTreeDocuments[4] = new StarTreeDocument(new Long[] { 3L, 11L, 21L }, new Double[] { 600.0 });
+        starTreeDocuments[5] = new StarTreeDocument(new Long[] { 3L, 12L, 23L }, new Double[] { 200.0 });
+        starTreeDocuments[6] = new StarTreeDocument(new Long[] { 3L, 12L, 21L }, new Double[] { 400.0 });
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            segmentStarTreeDocuments[i] = new StarTreeDocument(starTreeDocuments[i].dimensions, new Long[] { metric1 });
+        }
+
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateStarTreeDocuments(segmentStarTreeDocuments);
+        builder.build(segmentStarTreeDocumentIterator);
+
+        List<StarTreeDocument> resultStarTreeDocuments = builder.getStarTreeDocuments();
+        List<StarTreeDocument> expectedStarTreeDocuments = List.of(
+            new StarTreeDocument(new Long[] { 1L, 11L, 21L }, new Object[] { 400.0 }),
+            new StarTreeDocument(new Long[] { 1L, 12L, 22L }, new Object[] { 200.0 }),
+            new StarTreeDocument(new Long[] { 2L, 13L, 21L }, new Object[] { 100.0 }),
+            new StarTreeDocument(new Long[] { 2L, 13L, 23L }, new Object[] { 300.0 }),
+            new StarTreeDocument(new Long[] { 3L, 11L, 21L }, new Object[] { 600.0 }),
+            new StarTreeDocument(new Long[] { 3L, 12L, 21L }, new Object[] { 400.0 }),
+            new StarTreeDocument(new Long[] { 3L, 12L, 23L }, new Object[] { 200.0 }),
+            new StarTreeDocument(new Long[] { -1L, 11L, 21L }, new Object[] { 1000.0 }),
+            new StarTreeDocument(new Long[] { -1L, 12L, 21L }, new Object[] { 400.0 }),
+            new StarTreeDocument(new Long[] { -1L, 12L, 22L }, new Object[] { 200.0 }),
+            new StarTreeDocument(new Long[] { -1L, 12L, 23L }, new Object[] { 200.0 }),
+            new StarTreeDocument(new Long[] { -1L, 13L, 21L }, new Object[] { 100.0 }),
+            new StarTreeDocument(new Long[] { -1L, 13L, 23L }, new Object[] { 300.0 }),
+            new StarTreeDocument(new Long[] { -1L, -1L, 21L }, new Object[] { 1500.0 }),
+            new StarTreeDocument(new Long[] { -1L, -1L, 22L }, new Object[] { 200.0 }),
+            new StarTreeDocument(new Long[] { -1L, -1L, 23L }, new Object[] { 500.0 }),
+            new StarTreeDocument(new Long[] { -1L, -1L, -1L }, new Object[] { 2200.0 }),
+            new StarTreeDocument(new Long[] { -1L, 12L, -1L }, new Object[] { 800.0 }),
+            new StarTreeDocument(new Long[] { -1L, 13L, -1L }, new Object[] { 400.0 }),
+            new StarTreeDocument(new Long[] { 1L, -1L, 21L }, new Object[] { 400.0 }),
+            new StarTreeDocument(new Long[] { 1L, -1L, 22L }, new Object[] { 200.0 }),
+            new StarTreeDocument(new Long[] { 1L, -1L, -1L }, new Object[] { 600.0 }),
+            new StarTreeDocument(new Long[] { 2L, 13L, -1L }, new Object[] { 400.0 }),
+            new StarTreeDocument(new Long[] { 3L, -1L, 21L }, new Object[] { 1000.0 }),
+            new StarTreeDocument(new Long[] { 3L, -1L, 23L }, new Object[] { 200.0 }),
+            new StarTreeDocument(new Long[] { 3L, -1L, -1L }, new Object[] { 1200.0 }),
+            new StarTreeDocument(new Long[] { 3L, 12L, -1L }, new Object[] { 600.0 })
+        );
+
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = expectedStarTreeDocuments.iterator();
+        Iterator<StarTreeDocument> resultStarTreeDocumentIterator = resultStarTreeDocuments.iterator();
+        while (resultStarTreeDocumentIterator.hasNext() && expectedStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = resultStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+        }
+
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+        directory.close();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeDocValuesIteratorAdapterTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeDocValuesIteratorAdapterTests.java
new file mode 100644
index 0000000000000..9c2621401faa4
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeDocValuesIteratorAdapterTests.java
@@ -0,0 +1,139 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.IndexOptions;
+import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.index.VectorEncoding;
+import org.apache.lucene.index.VectorSimilarityFunction;
+import org.apache.lucene.search.DocIdSetIterator;
+import org.opensearch.index.compositeindex.datacube.startree.utils.SequentialDocValuesIterator;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.util.Collections;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class StarTreeDocValuesIteratorAdapterTests extends OpenSearchTestCase {
+
+    private StarTreeDocValuesIteratorAdapter adapter;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        adapter = new StarTreeDocValuesIteratorAdapter();
+    }
+
+    public void testGetDocValuesIterator() throws IOException {
+        DocValuesProducer mockProducer = mock(DocValuesProducer.class);
+        SortedNumericDocValues mockSortedNumericDocValues = mock(SortedNumericDocValues.class);
+
+        when(mockProducer.getSortedNumeric(any())).thenReturn(mockSortedNumericDocValues);
+
+        SequentialDocValuesIterator iterator = adapter.getDocValuesIterator(DocValuesType.SORTED_NUMERIC, any(), mockProducer);
+
+        assertNotNull(iterator);
+        assertEquals(mockSortedNumericDocValues, iterator.getDocIdSetIterator());
+    }
+
+    public void testGetDocValuesIteratorWithUnsupportedType() {
+        DocValuesProducer mockProducer = mock(DocValuesProducer.class);
+        FieldInfo fieldInfo = new FieldInfo(
+            "random_field",
+            0,
+            false,
+            false,
+            true,
+            IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS,
+            DocValuesType.SORTED_NUMERIC,
+            -1,
+            Collections.emptyMap(),
+            0,
+            0,
+            0,
+            0,
+            VectorEncoding.FLOAT32,
+            VectorSimilarityFunction.EUCLIDEAN,
+            false,
+            false
+        );
+        IllegalArgumentException exception = expectThrows(IllegalArgumentException.class, () -> {
+            adapter.getDocValuesIterator(DocValuesType.BINARY, fieldInfo, mockProducer);
+        });
+
+        assertEquals("Unsupported DocValuesType: BINARY", exception.getMessage());
+    }
+
+    public void testGetNextValue() throws IOException {
+        SortedNumericDocValues mockSortedNumericDocValues = mock(SortedNumericDocValues.class);
+        SequentialDocValuesIterator iterator = new SequentialDocValuesIterator(mockSortedNumericDocValues);
+        iterator.setDocId(1);
+        when(mockSortedNumericDocValues.nextValue()).thenReturn(42L);
+
+        Long nextValue = adapter.getNextValue(iterator, 1);
+
+        assertEquals(Long.valueOf(42L), nextValue);
+        assertEquals(Long.valueOf(42L), iterator.getDocValue());
+    }
+
+    public void testGetNextValueWithInvalidDocId() {
+        SortedNumericDocValues mockSortedNumericDocValues = mock(SortedNumericDocValues.class);
+        SequentialDocValuesIterator iterator = new SequentialDocValuesIterator(mockSortedNumericDocValues);
+        iterator.setDocId(DocIdSetIterator.NO_MORE_DOCS);
+
+        IllegalStateException exception = expectThrows(IllegalStateException.class, () -> { adapter.getNextValue(iterator, 1); });
+
+        assertEquals("invalid doc id to fetch the next value", exception.getMessage());
+    }
+
+    public void testGetNextValueWithUnsupportedIterator() {
+        DocIdSetIterator mockIterator = mock(DocIdSetIterator.class);
+        SequentialDocValuesIterator iterator = new SequentialDocValuesIterator(mockIterator);
+
+        IllegalStateException exception = expectThrows(IllegalStateException.class, () -> { adapter.getNextValue(iterator, 1); });
+
+        assertEquals("Unsupported Iterator: " + mockIterator.toString(), exception.getMessage());
+    }
+
+    public void testNextDoc() throws IOException {
+        SortedNumericDocValues mockSortedNumericDocValues = mock(SortedNumericDocValues.class);
+        SequentialDocValuesIterator iterator = new SequentialDocValuesIterator(mockSortedNumericDocValues);
+        when(mockSortedNumericDocValues.nextDoc()).thenReturn(2, 3, DocIdSetIterator.NO_MORE_DOCS);
+        when(mockSortedNumericDocValues.nextValue()).thenReturn(42L, 32L);
+
+        int nextDocId = adapter.nextDoc(iterator, 1);
+        assertEquals(2, nextDocId);
+        assertEquals(Long.valueOf(42L), adapter.getNextValue(iterator, nextDocId));
+
+        nextDocId = adapter.nextDoc(iterator, 2);
+        assertEquals(3, nextDocId);
+        when(mockSortedNumericDocValues.nextValue()).thenReturn(42L, 32L);
+
+    }
+
+    public void testNextDoc_noMoreDocs() throws IOException {
+        SortedNumericDocValues mockSortedNumericDocValues = mock(SortedNumericDocValues.class);
+        SequentialDocValuesIterator iterator = new SequentialDocValuesIterator(mockSortedNumericDocValues);
+        when(mockSortedNumericDocValues.nextDoc()).thenReturn(2, DocIdSetIterator.NO_MORE_DOCS);
+        when(mockSortedNumericDocValues.nextValue()).thenReturn(42L, 32L);
+
+        int nextDocId = adapter.nextDoc(iterator, 1);
+        assertEquals(2, nextDocId);
+        assertEquals(Long.valueOf(42L), adapter.getNextValue(iterator, nextDocId));
+
+        assertThrows(IllegalStateException.class, () -> adapter.nextDoc(iterator, 2));
+
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeValuesIteratorFactoryTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeValuesIteratorFactoryTests.java
new file mode 100644
index 0000000000000..1aba67533d52e
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeValuesIteratorFactoryTests.java
@@ -0,0 +1,131 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.IndexOptions;
+import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.index.VectorEncoding;
+import org.apache.lucene.index.VectorSimilarityFunction;
+import org.apache.lucene.search.DocIdSetIterator;
+import org.opensearch.index.compositeindex.datacube.startree.utils.SequentialDocValuesIterator;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.BeforeClass;
+
+import java.io.IOException;
+import java.util.Collections;
+
+import org.mockito.Mockito;
+
+import static org.mockito.Mockito.when;
+
+public class StarTreeValuesIteratorFactoryTests extends OpenSearchTestCase {
+
+    private static StarTreeDocValuesIteratorAdapter starTreeDocValuesIteratorAdapter;
+    private static FieldInfo mockFieldInfo;
+
+    @BeforeClass
+    public static void setup() {
+        starTreeDocValuesIteratorAdapter = new StarTreeDocValuesIteratorAdapter();
+        mockFieldInfo = new FieldInfo(
+            "field",
+            1,
+            false,
+            false,
+            true,
+            IndexOptions.NONE,
+            DocValuesType.NONE,
+            -1,
+            Collections.emptyMap(),
+            0,
+            0,
+            0,
+            0,
+            VectorEncoding.FLOAT32,
+            VectorSimilarityFunction.EUCLIDEAN,
+            false,
+            false
+        );
+    }
+
+    public void testCreateIterator_SortedNumeric() throws IOException {
+        DocValuesProducer producer = Mockito.mock(DocValuesProducer.class);
+        SortedNumericDocValues iterator = Mockito.mock(SortedNumericDocValues.class);
+        when(producer.getSortedNumeric(mockFieldInfo)).thenReturn(iterator);
+        SequentialDocValuesIterator result = starTreeDocValuesIteratorAdapter.getDocValuesIterator(
+            DocValuesType.SORTED_NUMERIC,
+            mockFieldInfo,
+            producer
+        );
+        assertEquals(iterator.getClass(), result.getDocIdSetIterator().getClass());
+    }
+
+    public void testCreateIterator_UnsupportedType() {
+        DocValuesProducer producer = Mockito.mock(DocValuesProducer.class);
+        IllegalArgumentException exception = expectThrows(IllegalArgumentException.class, () -> {
+            starTreeDocValuesIteratorAdapter.getDocValuesIterator(DocValuesType.BINARY, mockFieldInfo, producer);
+        });
+        assertEquals("Unsupported DocValuesType: BINARY", exception.getMessage());
+    }
+
+    public void testGetNextValue_SortedNumeric() throws IOException {
+        SortedNumericDocValues iterator = Mockito.mock(SortedNumericDocValues.class);
+        when(iterator.nextDoc()).thenReturn(0);
+        when(iterator.nextValue()).thenReturn(123L);
+        SequentialDocValuesIterator sequentialDocValuesIterator = new SequentialDocValuesIterator(iterator);
+        sequentialDocValuesIterator.getDocIdSetIterator().nextDoc();
+        long result = starTreeDocValuesIteratorAdapter.getNextValue(sequentialDocValuesIterator, 0);
+        assertEquals(123L, result);
+    }
+
+    public void testGetNextValue_UnsupportedIterator() {
+        DocIdSetIterator iterator = Mockito.mock(DocIdSetIterator.class);
+        SequentialDocValuesIterator sequentialDocValuesIterator = new SequentialDocValuesIterator(iterator);
+
+        IllegalStateException exception = expectThrows(IllegalStateException.class, () -> {
+            starTreeDocValuesIteratorAdapter.getNextValue(sequentialDocValuesIterator, 0);
+        });
+        assertEquals("Unsupported Iterator: " + iterator.toString(), exception.getMessage());
+    }
+
+    public void testNextDoc() throws IOException {
+        SortedNumericDocValues iterator = Mockito.mock(SortedNumericDocValues.class);
+        SequentialDocValuesIterator sequentialDocValuesIterator = new SequentialDocValuesIterator(iterator);
+        when(iterator.nextDoc()).thenReturn(5);
+
+        int result = starTreeDocValuesIteratorAdapter.nextDoc(sequentialDocValuesIterator, 5);
+        assertEquals(5, result);
+    }
+
+    public void test_multipleCoordinatedDocumentReader() throws IOException {
+        SortedNumericDocValues iterator1 = Mockito.mock(SortedNumericDocValues.class);
+        SortedNumericDocValues iterator2 = Mockito.mock(SortedNumericDocValues.class);
+
+        SequentialDocValuesIterator sequentialDocValuesIterator1 = new SequentialDocValuesIterator(iterator1);
+        SequentialDocValuesIterator sequentialDocValuesIterator2 = new SequentialDocValuesIterator(iterator2);
+
+        when(iterator1.nextDoc()).thenReturn(0);
+        when(iterator2.nextDoc()).thenReturn(1);
+
+        when(iterator1.nextValue()).thenReturn(9L);
+        when(iterator2.nextValue()).thenReturn(9L);
+
+        starTreeDocValuesIteratorAdapter.nextDoc(sequentialDocValuesIterator1, 0);
+        starTreeDocValuesIteratorAdapter.nextDoc(sequentialDocValuesIterator2, 0);
+        assertEquals(0, sequentialDocValuesIterator1.getDocId());
+        assertEquals(9L, (long) sequentialDocValuesIterator1.getDocValue());
+        assertNotEquals(0, sequentialDocValuesIterator2.getDocId());
+        assertEquals(1, sequentialDocValuesIterator2.getDocId());
+        assertEquals(9L, (long) sequentialDocValuesIterator2.getDocValue());
+
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreesBuilderTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreesBuilderTests.java
new file mode 100644
index 0000000000000..518c6729c2e1a
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreesBuilderTests.java
@@ -0,0 +1,132 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.codecs.lucene99.Lucene99Codec;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.FieldInfos;
+import org.apache.lucene.index.SegmentInfo;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.InfoStream;
+import org.apache.lucene.util.Version;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.mapper.StarTreeMapper;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+
+public class StarTreesBuilderTests extends OpenSearchTestCase {
+
+    private MapperService mapperService;
+    private SegmentWriteState segmentWriteState;
+    private DocValuesProducer docValuesProducer;
+    private StarTreeMapper.StarTreeFieldType starTreeFieldType;
+    private StarTreeField starTreeField;
+    private Map<String, DocValuesProducer> fieldProducerMap;
+    private Directory directory;
+
+    public void setUp() throws Exception {
+        super.setUp();
+        mapperService = mock(MapperService.class);
+        directory = newFSDirectory(createTempDir());
+        SegmentInfo segmentInfo = new SegmentInfo(
+            directory,
+            Version.LATEST,
+            Version.LUCENE_9_11_0,
+            "test_segment",
+            5,
+            false,
+            false,
+            new Lucene99Codec(),
+            new HashMap<>(),
+            UUID.randomUUID().toString().substring(0, 16).getBytes(StandardCharsets.UTF_8),
+            new HashMap<>(),
+            null
+        );
+        FieldInfos fieldInfos = new FieldInfos(new FieldInfo[0]);
+        segmentWriteState = new SegmentWriteState(
+            InfoStream.getDefault(),
+            segmentInfo.dir,
+            segmentInfo,
+            fieldInfos,
+            null,
+            newIOContext(random())
+        );
+        docValuesProducer = mock(DocValuesProducer.class);
+        StarTreeFieldConfiguration starTreeFieldConfiguration = new StarTreeFieldConfiguration(
+            1,
+            new HashSet<>(),
+            StarTreeFieldConfiguration.StarTreeBuildMode.ON_HEAP
+        );
+        starTreeField = new StarTreeField("star_tree", new ArrayList<>(), new ArrayList<>(), starTreeFieldConfiguration);
+        starTreeFieldType = new StarTreeMapper.StarTreeFieldType("star_tree", starTreeField);
+        fieldProducerMap = new HashMap<>();
+        fieldProducerMap.put("field1", docValuesProducer);
+    }
+
+    public void test_buildWithNoStarTreeFields() throws IOException {
+        when(mapperService.getCompositeFieldTypes()).thenReturn(new HashSet<>());
+
+        StarTreesBuilder starTreesBuilder = new StarTreesBuilder(fieldProducerMap, segmentWriteState, mapperService);
+        starTreesBuilder.build();
+
+        verifyNoInteractions(docValuesProducer);
+    }
+
+    public void test_getStarTreeBuilder() throws IOException {
+        when(mapperService.getCompositeFieldTypes()).thenReturn(Set.of(starTreeFieldType));
+        StarTreesBuilder starTreesBuilder = new StarTreesBuilder(fieldProducerMap, segmentWriteState, mapperService);
+        StarTreeBuilder starTreeBuilder = starTreesBuilder.getStarTreeBuilder(starTreeField, fieldProducerMap, segmentWriteState, mapperService);
+        assertTrue(starTreeBuilder instanceof OnHeapStarTreeBuilder);
+    }
+
+    public void test_getStarTreeBuilder_illegalArgument() {
+        when(mapperService.getCompositeFieldTypes()).thenReturn(Set.of(starTreeFieldType));
+        StarTreeFieldConfiguration starTreeFieldConfiguration = new StarTreeFieldConfiguration(1, new HashSet<>(), StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP);
+        StarTreeField starTreeField = new StarTreeField("star_tree", new ArrayList<>(), new ArrayList<>(), starTreeFieldConfiguration);
+        StarTreesBuilder starTreesBuilder = new StarTreesBuilder(fieldProducerMap, segmentWriteState, mapperService);
+        assertThrows(IllegalArgumentException.class, () -> starTreesBuilder.getStarTreeBuilder(starTreeField, fieldProducerMap, segmentWriteState, mapperService));
+    }
+
+    public void test_closeWithNoStarTreeFields() throws IOException {
+        StarTreeFieldConfiguration starTreeFieldConfiguration = new StarTreeFieldConfiguration(
+            1,
+            new HashSet<>(),
+            StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP
+        );
+        StarTreeField starTreeField = new StarTreeField("star_tree", new ArrayList<>(), new ArrayList<>(), starTreeFieldConfiguration);
+        starTreeFieldType = new StarTreeMapper.StarTreeFieldType("star_tree", starTreeField);
+        when(mapperService.getCompositeFieldTypes()).thenReturn(Set.of(starTreeFieldType));
+        StarTreesBuilder starTreesBuilder = new StarTreesBuilder(fieldProducerMap, segmentWriteState, mapperService);
+        starTreesBuilder.close();
+
+        verifyNoInteractions(docValuesProducer);
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+        directory.close();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/utils/SequentialDocValuesIteratorTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/utils/SequentialDocValuesIteratorTests.java
new file mode 100644
index 0000000000000..76b612e3677f7
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/utils/SequentialDocValuesIteratorTests.java
@@ -0,0 +1,46 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.utils;
+
+import org.apache.lucene.index.SortedNumericDocValues;
+import org.opensearch.index.fielddata.AbstractNumericDocValues;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+
+public class SequentialDocValuesIteratorTests extends OpenSearchTestCase {
+
+    public void test_sequentialDocValuesIterator() {
+        SequentialDocValuesIterator sequentialDocValuesIterator = new SequentialDocValuesIterator(new AbstractNumericDocValues() {
+            @Override
+            public long longValue() throws IOException {
+                return 0;
+            }
+
+            @Override
+            public boolean advanceExact(int i) throws IOException {
+                return false;
+            }
+
+            @Override
+            public int docID() {
+                return 0;
+            }
+        });
+
+        assertTrue(sequentialDocValuesIterator.getDocIdSetIterator() instanceof AbstractNumericDocValues);
+        assertEquals(sequentialDocValuesIterator.getDocId(), 0);
+    }
+
+    public void test_sequentialDocValuesIterator_default() {
+        SequentialDocValuesIterator sequentialDocValuesIterator = new SequentialDocValuesIterator();
+        assertTrue(sequentialDocValuesIterator.getDocIdSetIterator() instanceof SortedNumericDocValues);
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldMapperTests.java
index 65dd3b6447663..e9d0b6d826ade 100644
--- a/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldMapperTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldMapperTests.java
@@ -105,6 +105,14 @@ public void testMissingDefaultIndexMapper() throws Exception {
         assertThat(e.getMessage(), containsString("Field [field] is missing required parameter [value]"));
     }
 
+    public void testBuilderToXContent() throws IOException {
+        ConstantKeywordFieldMapper.Builder builder = new ConstantKeywordFieldMapper.Builder("name", "value1");
+        XContentBuilder xContentBuilder = JsonXContent.contentBuilder().startObject();
+        builder.toXContent(xContentBuilder, false);
+        xContentBuilder.endObject();
+        assertEquals("{\"value\":\"value1\"}", xContentBuilder.toString());
+    }
+
     private final SourceToParse source(CheckedConsumer<XContentBuilder, IOException> build) throws IOException {
         XContentBuilder builder = JsonXContent.contentBuilder().startObject();
         build.accept(builder);
diff --git a/server/src/test/java/org/opensearch/index/remote/RemoteStoreUtilsTests.java b/server/src/test/java/org/opensearch/index/remote/RemoteStoreUtilsTests.java
index 15915ee431972..ec48032df4a15 100644
--- a/server/src/test/java/org/opensearch/index/remote/RemoteStoreUtilsTests.java
+++ b/server/src/test/java/org/opensearch/index/remote/RemoteStoreUtilsTests.java
@@ -9,15 +9,29 @@
 package org.opensearch.index.remote;
 
 import org.opensearch.Version;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.IndexShardRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.ShardRoutingState;
+import org.opensearch.cluster.routing.TestShardRouting;
+import org.opensearch.common.UUIDs;
 import org.opensearch.common.blobstore.BlobMetadata;
 import org.opensearch.common.blobstore.support.PlainBlobMetadata;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.index.Index;
+import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.shard.IndexShardTestUtils;
 import org.opensearch.index.store.RemoteSegmentStoreDirectory;
 import org.opensearch.index.translog.transfer.TranslogTransferMetadata;
+import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.node.remotestore.RemoteStoreNodeAttribute;
 import org.opensearch.test.OpenSearchTestCase;
 
@@ -28,11 +42,15 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.UUID;
 import java.util.stream.Collectors;
 
 import static org.opensearch.cluster.metadata.IndexMetadata.REMOTE_STORE_CUSTOM_KEY;
+import static org.opensearch.index.remote.RemoteMigrationIndexMetadataUpdaterTests.createIndexMetadataWithDocrepSettings;
 import static org.opensearch.index.remote.RemoteStoreUtils.URL_BASE64_CHARSET;
 import static org.opensearch.index.remote.RemoteStoreUtils.determineTranslogMetadataEnabled;
+import static org.opensearch.index.remote.RemoteStoreUtils.finalizeMigration;
+import static org.opensearch.index.remote.RemoteStoreUtils.isSwitchToStrictCompatibilityMode;
 import static org.opensearch.index.remote.RemoteStoreUtils.longToCompositeBase64AndBinaryEncoding;
 import static org.opensearch.index.remote.RemoteStoreUtils.longToUrlBase64;
 import static org.opensearch.index.remote.RemoteStoreUtils.urlBase64ToLong;
@@ -42,6 +60,9 @@
 import static org.opensearch.index.store.RemoteSegmentStoreDirectory.MetadataFilenameUtils.METADATA_PREFIX;
 import static org.opensearch.index.store.RemoteSegmentStoreDirectory.MetadataFilenameUtils.SEPARATOR;
 import static org.opensearch.index.translog.transfer.TranslogTransferMetadata.METADATA_SEPARATOR;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY;
+import static org.opensearch.node.remotestore.RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING;
 
 public class RemoteStoreUtilsTests extends OpenSearchTestCase {
 
@@ -398,4 +419,122 @@ private static Map<String, String> getCustomDataMap(int option) {
         );
     }
 
+    public void testFinalizeMigrationWithAllRemoteNodes() {
+        String migratedIndex = "migrated-index";
+        Settings mockSettings = Settings.builder().put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "strict").build();
+        DiscoveryNode remoteNode1 = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            getRemoteStoreNodeAttributes(),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+        DiscoveryNode remoteNode2 = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            getRemoteStoreNodeAttributes(),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+        DiscoveryNodes discoveryNodes = DiscoveryNodes.builder()
+            .add(remoteNode1)
+            .localNodeId(remoteNode1.getId())
+            .add(remoteNode2)
+            .localNodeId(remoteNode2.getId())
+            .build();
+        Metadata docrepIdxMetadata = createIndexMetadataWithDocrepSettings(migratedIndex);
+        assertDocrepSettingsApplied(docrepIdxMetadata.index(migratedIndex));
+        Metadata remoteIndexMd = Metadata.builder(docrepIdxMetadata).persistentSettings(mockSettings).build();
+        ClusterState clusterStateWithDocrepIndexSettings = ClusterState.builder(ClusterName.DEFAULT)
+            .metadata(remoteIndexMd)
+            .nodes(discoveryNodes)
+            .routingTable(createRoutingTableAllShardsStarted(migratedIndex, 1, 1, remoteNode1, remoteNode2))
+            .build();
+        Metadata mutatedMetadata = finalizeMigration(clusterStateWithDocrepIndexSettings, logger).metadata();
+        assertTrue(mutatedMetadata.index(migratedIndex).getVersion() > docrepIdxMetadata.index(migratedIndex).getVersion());
+        assertRemoteSettingsApplied(mutatedMetadata.index(migratedIndex));
+    }
+
+    public void testFinalizeMigrationWithAllDocrepNodes() {
+        String docrepIndex = "docrep-index";
+        Settings mockSettings = Settings.builder().put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "strict").build();
+        DiscoveryNode docrepNode1 = new DiscoveryNode(UUIDs.base64UUID(), buildNewFakeTransportAddress(), Version.CURRENT);
+        DiscoveryNode docrepNode2 = new DiscoveryNode(UUIDs.base64UUID(), buildNewFakeTransportAddress(), Version.CURRENT);
+        DiscoveryNodes discoveryNodes = DiscoveryNodes.builder()
+            .add(docrepNode1)
+            .localNodeId(docrepNode1.getId())
+            .add(docrepNode2)
+            .localNodeId(docrepNode2.getId())
+            .build();
+        Metadata docrepIdxMetadata = createIndexMetadataWithDocrepSettings(docrepIndex);
+        assertDocrepSettingsApplied(docrepIdxMetadata.index(docrepIndex));
+        Metadata remoteIndexMd = Metadata.builder(docrepIdxMetadata).persistentSettings(mockSettings).build();
+        ClusterState clusterStateWithDocrepIndexSettings = ClusterState.builder(ClusterName.DEFAULT)
+            .metadata(remoteIndexMd)
+            .nodes(discoveryNodes)
+            .routingTable(createRoutingTableAllShardsStarted(docrepIndex, 1, 1, docrepNode1, docrepNode2))
+            .build();
+        Metadata mutatedMetadata = finalizeMigration(clusterStateWithDocrepIndexSettings, logger).metadata();
+        assertEquals(docrepIdxMetadata.index(docrepIndex).getVersion(), mutatedMetadata.index(docrepIndex).getVersion());
+        assertDocrepSettingsApplied(mutatedMetadata.index(docrepIndex));
+    }
+
+    public void testIsSwitchToStrictCompatibilityMode() {
+        Settings mockSettings = Settings.builder().put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "strict").build();
+        ClusterUpdateSettingsRequest request = new ClusterUpdateSettingsRequest();
+        request.persistentSettings(mockSettings);
+        assertTrue(isSwitchToStrictCompatibilityMode(request));
+
+        mockSettings = Settings.builder().put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "mixed").build();
+        request.persistentSettings(mockSettings);
+        assertFalse(isSwitchToStrictCompatibilityMode(request));
+    }
+
+    private void assertRemoteSettingsApplied(IndexMetadata indexMetadata) {
+        assertTrue(IndexMetadata.INDEX_REMOTE_STORE_ENABLED_SETTING.get(indexMetadata.getSettings()));
+        assertTrue(IndexMetadata.INDEX_REMOTE_TRANSLOG_REPOSITORY_SETTING.exists(indexMetadata.getSettings()));
+        assertTrue(IndexMetadata.INDEX_REMOTE_SEGMENT_STORE_REPOSITORY_SETTING.exists(indexMetadata.getSettings()));
+        assertEquals(ReplicationType.SEGMENT, IndexMetadata.INDEX_REPLICATION_TYPE_SETTING.get(indexMetadata.getSettings()));
+    }
+
+    private void assertDocrepSettingsApplied(IndexMetadata indexMetadata) {
+        assertFalse(IndexMetadata.INDEX_REMOTE_STORE_ENABLED_SETTING.get(indexMetadata.getSettings()));
+        assertFalse(IndexMetadata.INDEX_REMOTE_TRANSLOG_REPOSITORY_SETTING.exists(indexMetadata.getSettings()));
+        assertFalse(IndexMetadata.INDEX_REMOTE_SEGMENT_STORE_REPOSITORY_SETTING.exists(indexMetadata.getSettings()));
+        assertEquals(ReplicationType.DOCUMENT, IndexMetadata.INDEX_REPLICATION_TYPE_SETTING.get(indexMetadata.getSettings()));
+    }
+
+    private RoutingTable createRoutingTableAllShardsStarted(
+        String indexName,
+        int numberOfShards,
+        int numberOfReplicas,
+        DiscoveryNode primaryHostingNode,
+        DiscoveryNode replicaHostingNode
+    ) {
+        RoutingTable.Builder builder = RoutingTable.builder();
+        Index index = new Index(indexName, UUID.randomUUID().toString());
+
+        IndexRoutingTable.Builder indexRoutingTableBuilder = IndexRoutingTable.builder(index);
+        for (int i = 0; i < numberOfShards; i++) {
+            ShardId shardId = new ShardId(index, i);
+            IndexShardRoutingTable.Builder indexShardRoutingTable = new IndexShardRoutingTable.Builder(shardId);
+            indexShardRoutingTable.addShard(
+                TestShardRouting.newShardRouting(shardId, primaryHostingNode.getId(), true, ShardRoutingState.STARTED)
+            );
+            for (int j = 0; j < numberOfReplicas; j++) {
+                indexShardRoutingTable.addShard(
+                    TestShardRouting.newShardRouting(shardId, replicaHostingNode.getId(), false, ShardRoutingState.STARTED)
+                );
+            }
+            indexRoutingTableBuilder.addIndexShard(indexShardRoutingTable.build());
+        }
+        return builder.add(indexRoutingTableBuilder.build()).build();
+    }
+
+    private Map<String, String> getRemoteStoreNodeAttributes() {
+        Map<String, String> remoteStoreNodeAttributes = new HashMap<>();
+        remoteStoreNodeAttributes.put(REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY, "my-segment-repo-1");
+        remoteStoreNodeAttributes.put(REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY, "my-translog-repo-1");
+        return remoteStoreNodeAttributes;
+    }
 }
diff --git a/server/src/test/java/org/opensearch/indices/tiering/TieringRequestValidatorTests.java b/server/src/test/java/org/opensearch/indices/tiering/TieringRequestValidatorTests.java
new file mode 100644
index 0000000000000..6b6f74353812b
--- /dev/null
+++ b/server/src/test/java/org/opensearch/indices/tiering/TieringRequestValidatorTests.java
@@ -0,0 +1,318 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.tiering;
+
+import org.opensearch.Version;
+import org.opensearch.action.admin.indices.tiering.TieringValidationResult;
+import org.opensearch.cluster.ClusterInfo;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.DiskUsage;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.allocation.DiskThresholdSettings;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.index.Index;
+import org.opensearch.index.IndexModule;
+import org.opensearch.indices.replication.common.ReplicationType;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+import static org.opensearch.cluster.routing.allocation.DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_DISK_FLOOD_STAGE_WATERMARK_SETTING;
+import static org.opensearch.cluster.routing.allocation.DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK_SETTING;
+import static org.opensearch.cluster.routing.allocation.DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK_SETTING;
+import static org.opensearch.indices.tiering.TieringRequestValidator.getEligibleNodes;
+import static org.opensearch.indices.tiering.TieringRequestValidator.getIndexPrimaryStoreSize;
+import static org.opensearch.indices.tiering.TieringRequestValidator.getTotalAvailableBytesInWarmTier;
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateDiskThresholdWaterMarkNotBreached;
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateEligibleNodesCapacity;
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateHotIndex;
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateIndexHealth;
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateOpenIndex;
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateRemoteStoreIndex;
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateSearchNodes;
+
+public class TieringRequestValidatorTests extends OpenSearchTestCase {
+
+    public void testValidateSearchNodes() {
+        ClusterState clusterStateWithSearchNodes = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .nodes(createNodes(2, 0, 0))
+            .build();
+
+        // throws no errors
+        validateSearchNodes(clusterStateWithSearchNodes, "test_index");
+    }
+
+    public void testWithNoSearchNodesInCluster() {
+        ClusterState clusterStateWithNoSearchNodes = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .nodes(createNodes(0, 1, 1))
+            .build();
+        // throws error
+        IllegalArgumentException e = expectThrows(
+            IllegalArgumentException.class,
+            () -> validateSearchNodes(clusterStateWithNoSearchNodes, "test")
+        );
+    }
+
+    public void testValidRemoteStoreIndex() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+
+        ClusterState clusterState1 = buildClusterState(
+            indexName,
+            indexUuid,
+            Settings.builder()
+                .put(IndexMetadata.INDEX_REMOTE_STORE_ENABLED_SETTING.getKey(), true)
+                .put(IndexMetadata.INDEX_REPLICATION_TYPE_SETTING.getKey(), ReplicationType.SEGMENT)
+                .build()
+        );
+
+        assertTrue(validateRemoteStoreIndex(clusterState1, new Index(indexName, indexUuid)));
+    }
+
+    public void testDocRepIndex() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        assertFalse(validateRemoteStoreIndex(buildClusterState(indexName, indexUuid, Settings.EMPTY), new Index(indexName, indexUuid)));
+    }
+
+    public void testValidHotIndex() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        assertTrue(validateHotIndex(buildClusterState(indexName, indexUuid, Settings.EMPTY), new Index(indexName, indexUuid)));
+    }
+
+    public void testIndexWithOngoingOrCompletedTiering() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+
+        IndexModule.TieringState tieringState = randomBoolean() ? IndexModule.TieringState.HOT_TO_WARM : IndexModule.TieringState.WARM;
+
+        ClusterState clusterState = buildClusterState(
+            indexName,
+            indexUuid,
+            Settings.builder().put(IndexModule.INDEX_TIERING_STATE.getKey(), tieringState).build()
+        );
+        assertFalse(validateHotIndex(clusterState, new Index(indexName, indexUuid)));
+    }
+
+    public void testValidateIndexHealth() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        ClusterState clusterState = buildClusterState(indexName, indexUuid, Settings.EMPTY);
+        assertTrue(validateIndexHealth(clusterState, new Index(indexName, indexUuid)));
+    }
+
+    public void testValidOpenIndex() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        assertTrue(validateOpenIndex(buildClusterState(indexName, indexUuid, Settings.EMPTY), new Index(indexName, indexUuid)));
+    }
+
+    public void testCloseIndex() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        assertFalse(
+            validateOpenIndex(
+                buildClusterState(indexName, indexUuid, Settings.EMPTY, IndexMetadata.State.CLOSE),
+                new Index(indexName, indexUuid)
+            )
+        );
+    }
+
+    public void testValidateDiskThresholdWaterMarkNotBreached() {
+        int noOfNodes = 2;
+        ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .nodes(createNodes(noOfNodes, 0, 0))
+            .build();
+
+        ClusterInfo clusterInfo = clusterInfo(noOfNodes, 100, 20);
+        DiskThresholdSettings diskThresholdSettings = diskThresholdSettings("10b", "10b", "5b");
+        // throws no error
+        validateDiskThresholdWaterMarkNotBreached(clusterState, clusterInfo, diskThresholdSettings, "test");
+    }
+
+    public void testValidateDiskThresholdWaterMarkNotBreachedThrowsError() {
+        int noOfNodes = 2;
+        ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .nodes(createNodes(noOfNodes, 0, 0))
+            .build();
+        ClusterInfo clusterInfo = clusterInfo(noOfNodes, 100, 5);
+        DiskThresholdSettings diskThresholdSettings = diskThresholdSettings("10b", "10b", "5b");
+        // throws error
+        expectThrows(
+            IllegalArgumentException.class,
+            () -> validateDiskThresholdWaterMarkNotBreached(clusterState, clusterInfo, diskThresholdSettings, "test")
+        );
+    }
+
+    public void testGetTotalIndexSize() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        ClusterState clusterState = ClusterState.builder(buildClusterState(indexName, indexUuid, Settings.EMPTY))
+            .nodes(createNodes(1, 0, 0))
+            .build();
+        Map<String, DiskUsage> diskUsages = diskUsages(1, 100, 50);
+        final Map<String, Long> shardSizes = new HashMap<>();
+        shardSizes.put("[test_index][0][p]", 10L); // 10 bytes
+        ClusterInfo clusterInfo = new ClusterInfo(diskUsages, null, shardSizes, null, Map.of(), Map.of());
+        assertEquals(10, getIndexPrimaryStoreSize(clusterState, clusterInfo, indexName));
+    }
+
+    public void testValidateEligibleNodesCapacityWithAllAccepted() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        Set<Index> indices = Set.of(new Index(indexName, indexUuid));
+        ClusterState clusterState = ClusterState.builder(buildClusterState(indexName, indexUuid, Settings.EMPTY))
+            .nodes(createNodes(1, 0, 0))
+            .build();
+        Map<String, DiskUsage> diskUsages = diskUsages(1, 100, 50);
+        final Map<String, Long> shardSizes = new HashMap<>();
+        shardSizes.put("[test_index][0][p]", 10L); // 10 bytes
+        ClusterInfo clusterInfo = new ClusterInfo(diskUsages, null, shardSizes, null, Map.of(), Map.of());
+        TieringValidationResult tieringValidationResult = new TieringValidationResult(indices);
+        validateEligibleNodesCapacity(clusterInfo, clusterState, tieringValidationResult);
+        assertEquals(indices, tieringValidationResult.getAcceptedIndices());
+        assertTrue(tieringValidationResult.getRejectedIndices().isEmpty());
+    }
+
+    public void testValidateEligibleNodesCapacityWithAllRejected() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        Set<Index> indices = Set.of(new Index(indexName, indexUuid));
+        ClusterState clusterState = ClusterState.builder(buildClusterState(indexName, indexUuid, Settings.EMPTY))
+            .nodes(createNodes(1, 0, 0))
+            .build();
+        Map<String, DiskUsage> diskUsages = diskUsages(1, 100, 10);
+        final Map<String, Long> shardSizes = new HashMap<>();
+        shardSizes.put("[test_index][0][p]", 20L); // 20 bytes
+        ClusterInfo clusterInfo = new ClusterInfo(diskUsages, null, shardSizes, null, Map.of(), Map.of());
+        TieringValidationResult tieringValidationResult = new TieringValidationResult(indices);
+        validateEligibleNodesCapacity(clusterInfo, clusterState, tieringValidationResult);
+        assertEquals(indices.size(), tieringValidationResult.getRejectedIndices().size());
+        assertEquals(indices, tieringValidationResult.getRejectedIndices().keySet());
+        assertTrue(tieringValidationResult.getAcceptedIndices().isEmpty());
+    }
+
+    public void testGetTotalAvailableBytesInWarmTier() {
+        Map<String, DiskUsage> diskUsages = diskUsages(2, 500, 100);
+        assertEquals(200, getTotalAvailableBytesInWarmTier(diskUsages, Set.of("node-s0", "node-s1")));
+    }
+
+    public void testEligibleNodes() {
+        ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .nodes(createNodes(2, 0, 0))
+            .build();
+
+        assertEquals(2, getEligibleNodes(clusterState).size());
+
+        clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .nodes(createNodes(0, 1, 1))
+            .build();
+        assertEquals(0, getEligibleNodes(clusterState).size());
+    }
+
+    private static ClusterState buildClusterState(String indexName, String indexUuid, Settings settings) {
+        return buildClusterState(indexName, indexUuid, settings, IndexMetadata.State.OPEN);
+    }
+
+    private static ClusterState buildClusterState(String indexName, String indexUuid, Settings settings, IndexMetadata.State state) {
+        Settings combinedSettings = Settings.builder().put(settings).put(createDefaultIndexSettings(indexUuid)).build();
+
+        Metadata metadata = Metadata.builder().put(IndexMetadata.builder(indexName).settings(combinedSettings).state(state)).build();
+
+        RoutingTable routingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+
+        return ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .build();
+    }
+
+    private static Settings createDefaultIndexSettings(String indexUuid) {
+        return Settings.builder()
+            .put("index.version.created", Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, indexUuid)
+            .put(IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING.getKey(), 2)
+            .put(IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING.getKey(), 1)
+            .build();
+    }
+
+    private DiscoveryNodes createNodes(int numOfSearchNodes, int numOfDataNodes, int numOfIngestNodes) {
+        DiscoveryNodes.Builder discoveryNodesBuilder = DiscoveryNodes.builder();
+        for (int i = 0; i < numOfSearchNodes; i++) {
+            discoveryNodesBuilder.add(
+                new DiscoveryNode(
+                    "node-s" + i,
+                    buildNewFakeTransportAddress(),
+                    Collections.emptyMap(),
+                    Collections.singleton(DiscoveryNodeRole.SEARCH_ROLE),
+                    Version.CURRENT
+                )
+            );
+        }
+        for (int i = 0; i < numOfDataNodes; i++) {
+            discoveryNodesBuilder.add(
+                new DiscoveryNode(
+                    "node-d" + i,
+                    buildNewFakeTransportAddress(),
+                    Collections.emptyMap(),
+                    Collections.singleton(DiscoveryNodeRole.DATA_ROLE),
+                    Version.CURRENT
+                )
+            );
+        }
+        for (int i = 0; i < numOfIngestNodes; i++) {
+            discoveryNodesBuilder.add(
+                new DiscoveryNode(
+                    "node-i" + i,
+                    buildNewFakeTransportAddress(),
+                    Collections.emptyMap(),
+                    Collections.singleton(DiscoveryNodeRole.INGEST_ROLE),
+                    Version.CURRENT
+                )
+            );
+        }
+        return discoveryNodesBuilder.build();
+    }
+
+    private static DiskThresholdSettings diskThresholdSettings(String low, String high, String flood) {
+        return new DiskThresholdSettings(
+            Settings.builder()
+                .put(CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK_SETTING.getKey(), low)
+                .put(CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK_SETTING.getKey(), high)
+                .put(CLUSTER_ROUTING_ALLOCATION_DISK_FLOOD_STAGE_WATERMARK_SETTING.getKey(), flood)
+                .build(),
+            new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)
+        );
+    }
+
+    private static ClusterInfo clusterInfo(int noOfNodes, long totalBytes, long freeBytes) {
+        final Map<String, DiskUsage> diskUsages = diskUsages(noOfNodes, totalBytes, freeBytes);
+        return new ClusterInfo(diskUsages, null, null, null, Map.of(), Map.of());
+    }
+
+    private static Map<String, DiskUsage> diskUsages(int noOfSearchNodes, long totalBytes, long freeBytes) {
+        final Map<String, DiskUsage> diskUsages = new HashMap<>();
+        for (int i = 0; i < noOfSearchNodes; i++) {
+            diskUsages.put("node-s" + i, new DiskUsage("node-s" + i, "node-s" + i, "/foo/bar", totalBytes, freeBytes));
+        }
+        return diskUsages;
+    }
+}
diff --git a/server/src/test/java/org/opensearch/ingest/IngestServiceTests.java b/server/src/test/java/org/opensearch/ingest/IngestServiceTests.java
index 684297c11c140..166b94966196c 100644
--- a/server/src/test/java/org/opensearch/ingest/IngestServiceTests.java
+++ b/server/src/test/java/org/opensearch/ingest/IngestServiceTests.java
@@ -78,6 +78,7 @@
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.threadpool.ThreadPool.Names;
+import org.hamcrest.MatcherAssert;
 import org.junit.Before;
 
 import java.nio.charset.StandardCharsets;
@@ -104,15 +105,16 @@
 
 import static java.util.Collections.emptyMap;
 import static java.util.Collections.emptySet;
+import static org.hamcrest.Matchers.contains;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThanOrEqualTo;
+import static org.hamcrest.Matchers.hasSize;
 import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.notNullValue;
 import static org.hamcrest.Matchers.nullValue;
 import static org.hamcrest.Matchers.sameInstance;
 import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.anyInt;
 import static org.mockito.Mockito.anyString;
 import static org.mockito.Mockito.argThat;
 import static org.mockito.Mockito.doAnswer;
@@ -1106,27 +1108,23 @@ public void testExecuteFailureWithNestedOnFailure() throws Exception {
         verify(completionHandler, times(1)).accept(Thread.currentThread(), null);
     }
 
-    public void testBulkRequestExecutionWithFailures() throws Exception {
+    public void testBulkRequestExecutionWithFailures() {
         BulkRequest bulkRequest = new BulkRequest();
         String pipelineId = "_id";
 
-        int numRequest = scaledRandomIntBetween(8, 64);
-        int numIndexRequests = 0;
-        for (int i = 0; i < numRequest; i++) {
-            DocWriteRequest request;
+        int numIndexRequests = scaledRandomIntBetween(4, 32);
+        for (int i = 0; i < numIndexRequests; i++) {
+            IndexRequest indexRequest = new IndexRequest("_index").id("_id").setPipeline(pipelineId).setFinalPipeline("_none");
+            indexRequest.source(Requests.INDEX_CONTENT_TYPE, "field1", "value1");
+            bulkRequest.add(indexRequest);
+        }
+        int numOtherRequests = scaledRandomIntBetween(4, 32);
+        for (int i = 0; i < numOtherRequests; i++) {
             if (randomBoolean()) {
-                if (randomBoolean()) {
-                    request = new DeleteRequest("_index", "_id");
-                } else {
-                    request = new UpdateRequest("_index", "_id");
-                }
+                bulkRequest.add(new DeleteRequest("_index", "_id"));
             } else {
-                IndexRequest indexRequest = new IndexRequest("_index").id("_id").setPipeline(pipelineId).setFinalPipeline("_none");
-                indexRequest.source(Requests.INDEX_CONTENT_TYPE, "field1", "value1");
-                request = indexRequest;
-                numIndexRequests++;
+                bulkRequest.add(new UpdateRequest("_index", "_id"));
             }
-            bulkRequest.add(request);
         }
 
         CompoundProcessor processor = mock(CompoundProcessor.class);
@@ -1134,10 +1132,14 @@ public void testBulkRequestExecutionWithFailures() throws Exception {
         Exception error = new RuntimeException();
         doAnswer(args -> {
             @SuppressWarnings("unchecked")
-            BiConsumer<IngestDocument, Exception> handler = (BiConsumer) args.getArguments()[1];
-            handler.accept(null, error);
+            List<IngestDocumentWrapper> ingestDocumentWrappers = (List) args.getArguments()[0];
+            Consumer<List<IngestDocumentWrapper>> handler = (Consumer) args.getArguments()[1];
+            for (IngestDocumentWrapper wrapper : ingestDocumentWrappers) {
+                wrapper.update(wrapper.getIngestDocument(), error);
+            }
+            handler.accept(ingestDocumentWrappers);
             return null;
-        }).when(processor).execute(any(), any());
+        }).when(processor).batchExecute(any(), any());
         IngestService ingestService = createWithProcessors(
             Collections.singletonMap("mock", (factories, tag, description, config) -> processor)
         );
@@ -1151,23 +1153,22 @@ public void testBulkRequestExecutionWithFailures() throws Exception {
         clusterState = IngestService.innerPut(putRequest, clusterState);
         ingestService.applyClusterState(new ClusterChangedEvent("", clusterState, previousClusterState));
 
-        @SuppressWarnings("unchecked")
-        BiConsumer<Integer, Exception> requestItemErrorHandler = mock(BiConsumer.class);
-        @SuppressWarnings("unchecked")
-        final BiConsumer<Thread, Exception> completionHandler = mock(BiConsumer.class);
+        final Map<Integer, Exception> errorHandler = new HashMap<>();
+        final Map<Thread, Exception> completionHandler = new HashMap<>();
         ingestService.executeBulkRequest(
-            numRequest,
+            numIndexRequests + numOtherRequests,
             bulkRequest.requests(),
-            requestItemErrorHandler,
-            completionHandler,
+            errorHandler::put,
+            completionHandler::put,
             indexReq -> {},
             Names.WRITE,
             bulkRequest
         );
 
-        verify(requestItemErrorHandler, times(numIndexRequests)).accept(anyInt(), argThat(o -> o.getCause().equals(error)));
+        MatcherAssert.assertThat(errorHandler.entrySet(), hasSize(numIndexRequests));
+        errorHandler.values().forEach(e -> assertEquals(e.getCause(), error));
 
-        verify(completionHandler, times(1)).accept(Thread.currentThread(), null);
+        MatcherAssert.assertThat(completionHandler.keySet(), contains(Thread.currentThread()));
     }
 
     public void testBulkRequestExecution() throws Exception {
@@ -1192,10 +1193,11 @@ public void testBulkRequestExecution() throws Exception {
         when(processor.getTag()).thenReturn("mockTag");
         doAnswer(args -> {
             @SuppressWarnings("unchecked")
-            BiConsumer<IngestDocument, Exception> handler = (BiConsumer) args.getArguments()[1];
-            handler.accept(RandomDocumentPicks.randomIngestDocument(random()), null);
+            List<IngestDocumentWrapper> ingestDocumentWrappers = (List) args.getArguments()[0];
+            Consumer<List<IngestDocumentWrapper>> handler = (Consumer) args.getArguments()[1];
+            handler.accept(ingestDocumentWrappers);
             return null;
-        }).when(processor).execute(any(), any());
+        }).when(processor).batchExecute(any(), any());
         Map<String, Processor.Factory> map = new HashMap<>(2);
         map.put("mock", (factories, tag, description, config) -> processor);
 
@@ -1605,6 +1607,13 @@ public void testResolveRequiredOrDefaultPipelineDefaultPipeline() {
         assertThat(result, is(true));
         assertThat(indexRequest.isPipelineResolved(), is(true));
         assertThat(indexRequest.getPipeline(), equalTo("default-pipeline"));
+
+        // index name matches with ITMD for bulk upsert
+        UpdateRequest updateRequest = new UpdateRequest("idx", "id1").upsert(emptyMap()).script(mockScript("1"));
+        result = IngestService.resolvePipelines(updateRequest, TransportBulkAction.getIndexWriteRequest(updateRequest), metadata);
+        assertThat(result, is(true));
+        assertThat(updateRequest.upsertRequest().isPipelineResolved(), is(true));
+        assertThat(updateRequest.upsertRequest().getPipeline(), equalTo("default-pipeline"));
     }
 
     public void testResolveFinalPipeline() {
@@ -1642,6 +1651,13 @@ public void testResolveFinalPipeline() {
         assertThat(indexRequest.isPipelineResolved(), is(true));
         assertThat(indexRequest.getPipeline(), equalTo("_none"));
         assertThat(indexRequest.getFinalPipeline(), equalTo("final-pipeline"));
+
+        // index name matches with ITMD for bulk upsert:
+        UpdateRequest updateRequest = new UpdateRequest("idx", "id1").upsert(emptyMap()).script(mockScript("1"));
+        result = IngestService.resolvePipelines(updateRequest, TransportBulkAction.getIndexWriteRequest(updateRequest), metadata);
+        assertThat(result, is(true));
+        assertThat(updateRequest.upsertRequest().isPipelineResolved(), is(true));
+        assertThat(updateRequest.upsertRequest().getFinalPipeline(), equalTo("final-pipeline"));
     }
 
     public void testResolveRequestOrDefaultPipelineAndFinalPipeline() {
@@ -1943,6 +1959,42 @@ public void testExecuteBulkRequestInBatchWithExceptionAndDropInCallback() {
         verify(mockCompoundProcessor, never()).execute(any(), any());
     }
 
+    public void testExecuteBulkRequestInBatchWithDefaultBatchSize() {
+        CompoundProcessor mockCompoundProcessor = mockCompoundProcessor();
+        IngestService ingestService = createWithProcessors(
+            Collections.singletonMap("mock", (factories, tag, description, config) -> mockCompoundProcessor)
+        );
+        createPipeline("_id", ingestService);
+        BulkRequest bulkRequest = new BulkRequest();
+        IndexRequest indexRequest1 = new IndexRequest("_index").id("_id1").source(emptyMap()).setPipeline("_id").setFinalPipeline("_none");
+        bulkRequest.add(indexRequest1);
+        IndexRequest indexRequest2 = new IndexRequest("_index").id("_id2").source(emptyMap()).setPipeline("_id").setFinalPipeline("_none");
+        bulkRequest.add(indexRequest2);
+        IndexRequest indexRequest3 = new IndexRequest("_index").id("_id3").source(emptyMap()).setPipeline("_none").setFinalPipeline("_id");
+        bulkRequest.add(indexRequest3);
+        IndexRequest indexRequest4 = new IndexRequest("_index").id("_id4").source(emptyMap()).setPipeline("_id").setFinalPipeline("_none");
+        bulkRequest.add(indexRequest4);
+        @SuppressWarnings("unchecked")
+        final Map<Integer, Exception> failureHandler = new HashMap<>();
+        final Map<Thread, Exception> completionHandler = new HashMap<>();
+        final List<Integer> dropHandler = new ArrayList<>();
+        ingestService.executeBulkRequest(
+            4,
+            bulkRequest.requests(),
+            failureHandler::put,
+            completionHandler::put,
+            dropHandler::add,
+            Names.WRITE,
+            bulkRequest
+        );
+        assertTrue(failureHandler.isEmpty());
+        assertTrue(dropHandler.isEmpty());
+        assertEquals(1, completionHandler.size());
+        assertNull(completionHandler.get(Thread.currentThread()));
+        verify(mockCompoundProcessor, times(1)).batchExecute(any(), any());
+        verify(mockCompoundProcessor, never()).execute(any(), any());
+    }
+
     public void testPrepareBatches_same_index_pipeline() {
         IngestService.IndexRequestWrapper wrapper1 = createIndexRequestWrapper("index1", Collections.singletonList("p1"));
         IngestService.IndexRequestWrapper wrapper2 = createIndexRequestWrapper("index1", Collections.singletonList("p1"));
diff --git a/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryTests.java b/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryTests.java
index 2445cad01574c..bd47507da4863 100644
--- a/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryTests.java
+++ b/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryTests.java
@@ -255,6 +255,28 @@ public void testBadChunksize() throws Exception {
         );
     }
 
+    public void testPrefixModeVerification() throws Exception {
+        final Client client = client();
+        final Path location = OpenSearchIntegTestCase.randomRepoPath(node().settings());
+        final String repositoryName = "test-repo";
+        AcknowledgedResponse putRepositoryResponse = client.admin()
+            .cluster()
+            .preparePutRepository(repositoryName)
+            .setType(REPO_TYPE)
+            .setSettings(
+                Settings.builder()
+                    .put(node().settings())
+                    .put("location", location)
+                    .put(BlobStoreRepository.PREFIX_MODE_VERIFICATION_SETTING.getKey(), true)
+            )
+            .get();
+        assertTrue(putRepositoryResponse.isAcknowledged());
+
+        final RepositoriesService repositoriesService = getInstanceFromNode(RepositoriesService.class);
+        final BlobStoreRepository repository = (BlobStoreRepository) repositoriesService.repository(repositoryName);
+        assertTrue(repository.getPrefixModeVerification());
+    }
+
     public void testFsRepositoryCompressDeprecatedIgnored() {
         final Path location = OpenSearchIntegTestCase.randomRepoPath(node().settings());
         final Settings settings = Settings.builder().put(node().settings()).put("location", location).build();
diff --git a/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogramTests.java b/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogramTests.java
index 288b22ccfcc92..98c6ac2b3de45 100644
--- a/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogramTests.java
+++ b/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogramTests.java
@@ -33,10 +33,15 @@
 package org.opensearch.search.aggregations.bucket.histogram;
 
 import org.apache.lucene.tests.util.TestUtil;
+import org.opensearch.core.common.breaker.CircuitBreaker;
+import org.opensearch.core.common.breaker.CircuitBreakingException;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.aggregations.BucketOrder;
+import org.opensearch.search.aggregations.InternalAggregation;
 import org.opensearch.search.aggregations.InternalAggregations;
+import org.opensearch.search.aggregations.MultiBucketConsumerService;
 import org.opensearch.search.aggregations.ParsedMultiBucketAggregation;
+import org.opensearch.search.aggregations.pipeline.PipelineAggregator;
 import org.opensearch.test.InternalAggregationTestCase;
 import org.opensearch.test.InternalMultiBucketAggregationTestCase;
 
@@ -47,6 +52,8 @@
 import java.util.Map;
 import java.util.TreeMap;
 
+import org.mockito.Mockito;
+
 public class InternalHistogramTests extends InternalMultiBucketAggregationTestCase<InternalHistogram> {
 
     private boolean keyed;
@@ -123,6 +130,42 @@ public void testHandlesNaN() {
         );
     }
 
+    public void testCircuitBreakerWhenAddEmptyBuckets() {
+        String name = randomAlphaOfLength(5);
+        double interval = 1;
+        double lowerBound = 1;
+        double upperBound = 1026;
+        List<InternalHistogram.Bucket> bucket1 = List.of(
+            new InternalHistogram.Bucket(lowerBound, 1, false, format, InternalAggregations.EMPTY)
+        );
+        List<InternalHistogram.Bucket> bucket2 = List.of(
+            new InternalHistogram.Bucket(upperBound, 1, false, format, InternalAggregations.EMPTY)
+        );
+        BucketOrder order = BucketOrder.key(true);
+        InternalHistogram.EmptyBucketInfo emptyBucketInfo = new InternalHistogram.EmptyBucketInfo(
+            interval,
+            0,
+            lowerBound,
+            upperBound,
+            InternalAggregations.EMPTY
+        );
+        InternalHistogram histogram1 = new InternalHistogram(name, bucket1, order, 0, emptyBucketInfo, format, false, null);
+        InternalHistogram histogram2 = new InternalHistogram(name, bucket2, order, 0, emptyBucketInfo, format, false, null);
+
+        CircuitBreaker breaker = Mockito.mock(CircuitBreaker.class);
+        Mockito.when(breaker.addEstimateBytesAndMaybeBreak(0, "allocated_buckets")).thenThrow(CircuitBreakingException.class);
+
+        MultiBucketConsumerService.MultiBucketConsumer bucketConsumer = new MultiBucketConsumerService.MultiBucketConsumer(0, breaker);
+        InternalAggregation.ReduceContext reduceContext = InternalAggregation.ReduceContext.forFinalReduction(
+            null,
+            null,
+            bucketConsumer,
+            PipelineAggregator.PipelineTree.EMPTY
+        );
+        expectThrows(CircuitBreakingException.class, () -> histogram1.reduce(List.of(histogram1, histogram2), reduceContext));
+        Mockito.verify(breaker, Mockito.times(1)).addEstimateBytesAndMaybeBreak(0, "allocated_buckets");
+    }
+
     @Override
     protected void assertReduced(InternalHistogram reduced, List<InternalHistogram> inputs) {
         TreeMap<Double, Long> expectedCounts = new TreeMap<>();
diff --git a/settings.gradle b/settings.gradle
index a96d00a4ab863..ae9f5384be592 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -10,7 +10,7 @@
  */
 
 plugins {
-  id "com.gradle.develocity" version "3.17.5"
+  id "com.gradle.develocity" version "3.17.6"
 }
 
 ext.disableBuildCache = hasProperty('DISABLE_BUILD_CACHE') || System.getenv().containsKey('DISABLE_BUILD_CACHE')
diff --git a/test/fixtures/hdfs-fixture/build.gradle b/test/fixtures/hdfs-fixture/build.gradle
index a3c2932be64c4..9b8f62b8c55b8 100644
--- a/test/fixtures/hdfs-fixture/build.gradle
+++ b/test/fixtures/hdfs-fixture/build.gradle
@@ -76,7 +76,7 @@ dependencies {
   api "ch.qos.logback:logback-core:1.5.6"
   api "ch.qos.logback:logback-classic:1.2.13"
   api "org.jboss.xnio:xnio-nio:3.8.16.Final"
-  api 'org.jline:jline:3.26.2'
+  api 'org.jline:jline:3.26.3'
   api 'org.apache.commons:commons-configuration2:2.11.0'
   api 'com.nimbusds:nimbus-jose-jwt:9.40'
   api ('org.apache.kerby:kerb-admin:2.0.3') {
diff --git a/test/framework/src/main/java/org/opensearch/cluster/service/applicationtemplates/TestSystemTemplatesRepositoryPlugin.java b/test/framework/src/main/java/org/opensearch/cluster/service/applicationtemplates/TestSystemTemplatesRepositoryPlugin.java
new file mode 100644
index 0000000000000..c5245c7109d8f
--- /dev/null
+++ b/test/framework/src/main/java/org/opensearch/cluster/service/applicationtemplates/TestSystemTemplatesRepositoryPlugin.java
@@ -0,0 +1,72 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.service.applicationtemplates;
+
+import org.opensearch.cluster.applicationtemplates.SystemTemplate;
+import org.opensearch.cluster.applicationtemplates.SystemTemplateLoader;
+import org.opensearch.cluster.applicationtemplates.SystemTemplateMetadata;
+import org.opensearch.cluster.applicationtemplates.SystemTemplateRepository;
+import org.opensearch.cluster.applicationtemplates.SystemTemplatesPlugin;
+import org.opensearch.cluster.applicationtemplates.TemplateRepositoryMetadata;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.plugins.Plugin;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+public class TestSystemTemplatesRepositoryPlugin extends Plugin implements SystemTemplatesPlugin {
+
+    private final SystemTemplateMetadata templateMetadata = SystemTemplateMetadata.fromComponentTemplateInfo("dummy", 1);
+
+    private final TemplateRepositoryMetadata repoMetadata = new TemplateRepositoryMetadata("test", 1);
+
+    private final SystemTemplate systemTemplate = new SystemTemplate(
+        BytesReference.fromByteBuffer(ByteBuffer.wrap("content".getBytes(StandardCharsets.UTF_8))),
+        templateMetadata,
+        repoMetadata
+    );
+
+    @Override
+    public SystemTemplateRepository loadRepository() throws IOException {
+        return new SystemTemplateRepository() {
+            @Override
+            public TemplateRepositoryMetadata metadata() {
+                return repoMetadata;
+            }
+
+            @Override
+            public List<SystemTemplateMetadata> listTemplates() throws IOException {
+                return List.of(templateMetadata);
+            }
+
+            @Override
+            public SystemTemplate getTemplate(SystemTemplateMetadata template) throws IOException {
+                return systemTemplate;
+            }
+
+            @Override
+            public void close() throws Exception {}
+        };
+    }
+
+    @Override
+    public SystemTemplateLoader loaderFor(SystemTemplateMetadata templateMetadata) {
+        return new SystemTemplateLoader() { // Asserting Loader
+            @Override
+            public boolean loadTemplate(SystemTemplate template) throws IOException {
+                assert template.templateMetadata() == TestSystemTemplatesRepositoryPlugin.this.templateMetadata;
+                assert template.repositoryMetadata() == repoMetadata;
+                assert template.templateContent() == systemTemplate.templateContent();
+                return true;
+            }
+        };
+    }
+}
diff --git a/test/framework/src/main/java/org/opensearch/indices/analysis/AnalysisFactoryTestCase.java b/test/framework/src/main/java/org/opensearch/indices/analysis/AnalysisFactoryTestCase.java
index 5231fe095f0f0..23cf4d47a49d9 100644
--- a/test/framework/src/main/java/org/opensearch/indices/analysis/AnalysisFactoryTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/indices/analysis/AnalysisFactoryTestCase.java
@@ -139,6 +139,7 @@ public abstract class AnalysisFactoryTestCase extends OpenSearchTestCase {
         .put("patterncapturegroup", MovedToAnalysisCommon.class)
         .put("patternreplace", MovedToAnalysisCommon.class)
         .put("persiannormalization", MovedToAnalysisCommon.class)
+        .put("persianstem", MovedToAnalysisCommon.class)
         .put("porterstem", MovedToAnalysisCommon.class)
         .put("portuguesestem", MovedToAnalysisCommon.class)
         .put("portugueselightstem", MovedToAnalysisCommon.class)
@@ -219,7 +220,6 @@ public abstract class AnalysisFactoryTestCase extends OpenSearchTestCase {
         .put("spanishpluralstem", Void.class)
         // LUCENE-10352
         .put("daitchmokotoffsoundex", Void.class)
-        .put("persianstem", Void.class)
         // https://github.com/apache/lucene/pull/12169
         .put("word2vecsynonym", Void.class)
         // https://github.com/apache/lucene/pull/12915
diff --git a/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java b/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
index ca5ddf21710af..b86cce682c68e 100644
--- a/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
@@ -90,6 +90,7 @@
 import org.opensearch.cluster.routing.allocation.decider.AwarenessAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.EnableAllocationDecider;
 import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.cluster.service.applicationtemplates.TestSystemTemplatesRepositoryPlugin;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.Priority;
 import org.opensearch.common.collect.Tuple;
@@ -151,6 +152,8 @@
 import org.opensearch.node.remotestore.RemoteStoreNodeService;
 import org.opensearch.plugins.NetworkPlugin;
 import org.opensearch.plugins.Plugin;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.repositories.fs.FsRepository;
 import org.opensearch.repositories.fs.ReloadableFsRepository;
 import org.opensearch.script.MockScriptService;
 import org.opensearch.search.MockSearchService;
@@ -218,6 +221,7 @@
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING;
@@ -385,6 +389,8 @@ public abstract class OpenSearchIntegTestCase extends OpenSearchTestCase {
 
     protected static final String REMOTE_BACKED_STORAGE_REPOSITORY_NAME = "test-remote-store-repo";
 
+    private static Boolean prefixModeVerificationEnable;
+
     private Path remoteStoreRepositoryPath;
 
     private ReplicationType randomReplicationType;
@@ -393,6 +399,7 @@ public abstract class OpenSearchIntegTestCase extends OpenSearchTestCase {
 
     @BeforeClass
     public static void beforeClass() throws Exception {
+        prefixModeVerificationEnable = randomBoolean();
         testClusterRule.beforeClass();
     }
 
@@ -682,6 +689,7 @@ protected Settings featureFlagSettings() {
         }
         // Enabling Telemetry setting by default
         featureSettings.put(FeatureFlags.TELEMETRY_SETTING.getKey(), true);
+        featureSettings.put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES_SETTING.getKey(), true);
 
         return featureSettings.build();
     }
@@ -2168,6 +2176,7 @@ protected Collection<Class<? extends Plugin>> getMockPlugins() {
         if (addMockTelemetryPlugin()) {
             mocks.add(MockTelemetryPlugin.class);
         }
+        mocks.add(TestSystemTemplatesRepositoryPlugin.class);
         return Collections.unmodifiableList(mocks);
     }
 
@@ -2573,6 +2582,35 @@ public static Settings remoteStoreClusterSettings(
         return settingsBuilder.build();
     }
 
+    public static Settings remoteStoreClusterSettings(
+        String segmentRepoName,
+        Path segmentRepoPath,
+        String segmentRepoType,
+        String translogRepoName,
+        Path translogRepoPath,
+        String translogRepoType,
+        String routingTableRepoName,
+        Path routingTableRepoPath,
+        String routingTableRepoType
+    ) {
+        Settings.Builder settingsBuilder = Settings.builder();
+        settingsBuilder.put(
+            buildRemoteStoreNodeAttributes(
+                segmentRepoName,
+                segmentRepoPath,
+                segmentRepoType,
+                translogRepoName,
+                translogRepoPath,
+                translogRepoType,
+                routingTableRepoName,
+                routingTableRepoPath,
+                routingTableRepoType,
+                false
+            )
+        );
+        return settingsBuilder.build();
+    }
+
     public static Settings remoteStoreClusterSettings(
         String segmentRepoName,
         Path segmentRepoPath,
@@ -2584,6 +2622,29 @@ public static Settings remoteStoreClusterSettings(
         return settingsBuilder.build();
     }
 
+    public static Settings remoteStoreClusterSettings(
+        String segmentRepoName,
+        Path segmentRepoPath,
+        String translogRepoName,
+        Path translogRepoPath,
+        String remoteRoutingTableRepoName,
+        Path remoteRoutingTableRepoPath
+    ) {
+        Settings.Builder settingsBuilder = Settings.builder();
+        settingsBuilder.put(
+            buildRemoteStoreNodeAttributes(
+                segmentRepoName,
+                segmentRepoPath,
+                translogRepoName,
+                translogRepoPath,
+                remoteRoutingTableRepoName,
+                remoteRoutingTableRepoPath,
+                false
+            )
+        );
+        return settingsBuilder.build();
+    }
+
     public static Settings buildRemoteStoreNodeAttributes(
         String segmentRepoName,
         Path segmentRepoPath,
@@ -2602,6 +2663,52 @@ public static Settings buildRemoteStoreNodeAttributes(
         );
     }
 
+    public static Settings buildRemoteStoreNodeAttributes(
+        String segmentRepoName,
+        Path segmentRepoPath,
+        String translogRepoName,
+        Path translogRepoPath,
+        String remoteRoutingTableRepoName,
+        Path remoteRoutingTableRepoPath,
+        boolean withRateLimiterAttributes
+    ) {
+        return buildRemoteStoreNodeAttributes(
+            segmentRepoName,
+            segmentRepoPath,
+            ReloadableFsRepository.TYPE,
+            translogRepoName,
+            translogRepoPath,
+            ReloadableFsRepository.TYPE,
+            remoteRoutingTableRepoName,
+            remoteRoutingTableRepoPath,
+            FsRepository.TYPE,
+            withRateLimiterAttributes
+        );
+    }
+
+    private static Settings buildRemoteStoreNodeAttributes(
+        String segmentRepoName,
+        Path segmentRepoPath,
+        String segmentRepoType,
+        String translogRepoName,
+        Path translogRepoPath,
+        String translogRepoType,
+        boolean withRateLimiterAttributes
+    ) {
+        return buildRemoteStoreNodeAttributes(
+            segmentRepoName,
+            segmentRepoPath,
+            segmentRepoType,
+            translogRepoName,
+            translogRepoPath,
+            translogRepoType,
+            null,
+            null,
+            null,
+            withRateLimiterAttributes
+        );
+    }
+
     private static Settings buildRemoteStoreNodeAttributes(
         String segmentRepoName,
         Path segmentRepoPath,
@@ -2609,6 +2716,9 @@ private static Settings buildRemoteStoreNodeAttributes(
         String translogRepoName,
         Path translogRepoPath,
         String translogRepoType,
+        String routingTableRepoName,
+        Path routingTableRepoPath,
+        String routingTableRepoType,
         boolean withRateLimiterAttributes
     ) {
         String segmentRepoTypeAttributeKey = String.format(
@@ -2641,17 +2751,40 @@ private static Settings buildRemoteStoreNodeAttributes(
             "node.attr." + REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
             segmentRepoName
         );
+        String routingTableRepoAttributeKey = null, routingTableRepoSettingsAttributeKeyPrefix = null;
+        if (routingTableRepoName != null) {
+            routingTableRepoAttributeKey = String.format(
+                Locale.getDefault(),
+                "node.attr." + REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT,
+                routingTableRepoName
+            );
+            routingTableRepoSettingsAttributeKeyPrefix = String.format(
+                Locale.getDefault(),
+                "node.attr." + REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
+                routingTableRepoName
+            );
+        }
+
+        String prefixModeVerificationSuffix = BlobStoreRepository.PREFIX_MODE_VERIFICATION_SETTING.getKey();
 
         Settings.Builder settings = Settings.builder()
             .put("node.attr." + REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY, segmentRepoName)
             .put(segmentRepoTypeAttributeKey, segmentRepoType)
             .put(segmentRepoSettingsAttributeKeyPrefix + "location", segmentRepoPath)
+            .put(segmentRepoSettingsAttributeKeyPrefix + prefixModeVerificationSuffix, prefixModeVerificationEnable)
             .put("node.attr." + REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY, translogRepoName)
             .put(translogRepoTypeAttributeKey, translogRepoType)
             .put(translogRepoSettingsAttributeKeyPrefix + "location", translogRepoPath)
+            .put(translogRepoSettingsAttributeKeyPrefix + prefixModeVerificationSuffix, prefixModeVerificationEnable)
             .put("node.attr." + REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, segmentRepoName)
             .put(stateRepoTypeAttributeKey, segmentRepoType)
-            .put(stateRepoSettingsAttributeKeyPrefix + "location", segmentRepoPath);
+            .put(stateRepoSettingsAttributeKeyPrefix + "location", segmentRepoPath)
+            .put(stateRepoSettingsAttributeKeyPrefix + prefixModeVerificationSuffix, prefixModeVerificationEnable);
+        if (routingTableRepoName != null) {
+            settings.put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, routingTableRepoName)
+                .put(routingTableRepoAttributeKey, routingTableRepoType)
+                .put(routingTableRepoSettingsAttributeKeyPrefix + "location", routingTableRepoPath);
+        }
 
         if (withRateLimiterAttributes) {
             settings.put(segmentRepoSettingsAttributeKeyPrefix + "compress", randomBoolean())
diff --git a/test/framework/src/main/java/org/opensearch/test/OpenSearchSingleNodeTestCase.java b/test/framework/src/main/java/org/opensearch/test/OpenSearchSingleNodeTestCase.java
index 45ea63e862df6..1dfad60c04155 100644
--- a/test/framework/src/main/java/org/opensearch/test/OpenSearchSingleNodeTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/test/OpenSearchSingleNodeTestCase.java
@@ -438,6 +438,7 @@ protected Settings featureFlagSettings() {
             featureSettings.put(builtInFlag.getKey(), builtInFlag.getDefaultRaw(Settings.EMPTY));
         }
         featureSettings.put(FeatureFlags.TELEMETRY_SETTING.getKey(), true);
+        featureSettings.put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES_SETTING.getKey(), true);
         return featureSettings.build();
     }