diff --git a/app/assets/javascripts/admin/database_diagnostics/components/collation_checker.vue b/app/assets/javascripts/admin/database_diagnostics/components/collation_checker.vue
new file mode 100644
index 0000000000000000000000000000000000000000..61c0e2b78cc9213fa7b4061676606ecfde8679a4
--- /dev/null
+++ b/app/assets/javascripts/admin/database_diagnostics/components/collation_checker.vue
@@ -0,0 +1,440 @@
+<script>
+import { GlAlert, GlButton, GlIcon, GlLoadingIcon, GlTable, GlBadge, GlCard } from '@gitlab/ui';
+import axios from '~/lib/utils/axios_utils';
+import { __, s__, sprintf } from '~/locale';
+import { formatDate } from '~/lib/utils/datetime_utility';
+import { helpPagePath } from '~/helpers/help_page_helper';
+import { bytes } from '~/lib/utils/unit_format';
+import { SUPPORT_URL } from '~/sessions/new/constants';
+
+export const POLLING_INTERVAL_MS = 5000; // 5 seconds
+export const MAX_POLLING_ATTEMPTS = 60; // 5 minutes total (60 × 5 seconds)
+
+export default {
+  name: 'CollationChecker',
+  components: {
+    GlAlert,
+    GlButton,
+    GlIcon,
+    GlLoadingIcon,
+    GlTable,
+    GlBadge,
+    GlCard,
+  },
+  supportUrl: SUPPORT_URL,
+  collationMismatchFields: [
+    { key: 'collation_name', label: __('Collation Name') },
+    { key: 'provider', label: __('Provider') },
+    { key: 'stored_version', label: __('Stored Version') },
+    { key: 'actual_version', label: __('Actual Version') },
+  ],
+  corruptedIndexesFields: [
+    { key: 'index_name', label: __('Index Name') },
+    { key: 'table_name', label: __('Table') },
+    { key: 'affected_columns', label: __('Affected Columns') },
+    { key: 'index_type', label: __('Type') },
+    { key: 'is_unique', label: __('Unique') },
+    { key: 'size', label: __('Size') },
+    { key: 'corruption_types', label: __('Issues') },
+  ],
+  props: {
+    runCollationCheckUrl: {
+      type: String,
+      required: true,
+    },
+    collationCheckResultsUrl: {
+      type: String,
+      required: true,
+    },
+    pollingIntervalMs: {
+      type: Number,
+      required: false,
+      default: POLLING_INTERVAL_MS,
+    },
+    maxPollingAttempts: {
+      type: Number,
+      required: false,
+      default: MAX_POLLING_ATTEMPTS,
+    },
+  },
+  data() {
+    return {
+      isLoading: false,
+      isRunning: false,
+      isInitialLoad: true,
+      results: null,
+      error: null,
+      pollingId: null,
+      pollingAttempts: 0,
+    };
+  },
+  computed: {
+    formattedLastRunAt() {
+      if (!this.results?.metadata?.last_run_at) {
+        return '';
+      }
+      return formatDate(new Date(this.results.metadata.last_run_at));
+    },
+    hasResults() {
+      return this.results !== null && this.results.databases;
+    },
+    hasIssues() {
+      if (!this.results?.databases) return false;
+
+      return Object.values(this.results.databases).some((db) => db.corrupted_indexes?.length > 0);
+    },
+    documentationUrl() {
+      return helpPagePath('administration/postgresql/upgrading_os');
+    },
+    shouldShowNoResultsMessage() {
+      return !this.hasResults && !this.isLoading && !this.isRunning && !this.isInitialLoad;
+    },
+  },
+  created() {
+    this.fetchResults();
+  },
+  beforeDestroy() {
+    this.stopPolling();
+  },
+  methods: {
+    bytes,
+    sprintf,
+
+    async fetchResults() {
+      this.isInitialLoad = true;
+      this.isLoading = true;
+      this.error = null;
+
+      try {
+        const { data } = await axios.get(this.collationCheckResultsUrl);
+        if (data) {
+          this.results = data;
+        }
+      } catch (error) {
+        if (error.response?.status === 404) {
+          this.error = null;
+        } else {
+          this.error =
+            error.response?.data?.error ?? __('An error occurred while fetching results');
+        }
+      } finally {
+        this.isLoading = false;
+        this.isInitialLoad = false;
+      }
+    },
+
+    async runDatabaseDiagnostics() {
+      this.isLoading = true;
+      this.isRunning = true;
+      this.error = null;
+
+      try {
+        await axios.post(this.runCollationCheckUrl);
+        this.startPolling();
+      } catch (error) {
+        this.isLoading = false;
+        this.isRunning = false;
+        this.error =
+          error.response?.data?.error ?? __('An error occurred while starting diagnostics');
+      }
+    },
+
+    startPolling() {
+      this.stopPolling();
+
+      this.pollingId = setInterval(() => {
+        this.pollResults();
+      }, this.pollingIntervalMs);
+    },
+
+    stopPolling() {
+      if (this.pollingId) {
+        clearInterval(this.pollingId);
+        this.pollingId = null;
+      }
+      this.pollingAttempts = 0;
+    },
+
+    async pollResults() {
+      try {
+        const { data } = await axios.get(this.collationCheckResultsUrl);
+
+        if (data?.databases) {
+          this.results = data;
+          this.isLoading = false;
+          this.isRunning = false;
+          this.stopPolling();
+        }
+      } catch (error) {
+        if (error.response?.status === 404) {
+          this.pollingAttempts += 1;
+
+          if (this.pollingAttempts >= this.maxPollingAttempts) {
+            this.stopPolling();
+            this.isLoading = false;
+            this.isRunning = false;
+            this.error = s__(
+              'DatabaseDiagnostics|The database diagnostic job is taking longer than expected. You can check back later or try running it again.',
+            );
+          }
+          return;
+        }
+
+        this.isLoading = false;
+        this.isRunning = false;
+        this.stopPolling();
+        this.error = error.response?.data?.error ?? __('An error occurred while fetching results');
+      }
+    },
+
+    hasMismatches(dbResults) {
+      return dbResults.collation_mismatches?.length > 0;
+    },
+
+    hasCorruptedIndexes(dbResults) {
+      return dbResults.corrupted_indexes?.length > 0;
+    },
+
+    formatBytes(byteSize) {
+      return this.bytes(byteSize);
+    },
+  },
+};
+</script>
+
+<template>
+  <div class="gl-mt-3">
+    <div class="gl-display-flex gl-justify-content-between gl-mb-5 gl-flex-wrap gl-gap-3">
+      <div>
+        <h2 class="gl-heading-4" data-testid="title">
+          {{ s__('DatabaseDiagnostics|Collation Health Check') }}
+        </h2>
+        <p class="gl-text-secondary">
+          {{
+            s__(
+              'DatabaseDiagnostics|Detect collation-related index corruption issues that may occur after OS upgrades',
+            )
+          }}
+          <small
+            v-if="results && results.metadata && results.metadata.last_run_at"
+            class="gl-ml-2"
+            data-testid="last-run"
+          >
+            {{
+              sprintf(s__('DatabaseDiagnostics|Last checked: %{timestamp}'), {
+                timestamp: formattedLastRunAt,
+              })
+            }}
+          </small>
+        </p>
+      </div>
+      <div>
+        <gl-button
+          variant="confirm"
+          :disabled="isLoading || isRunning"
+          data-testid="run-diagnostics-button"
+          @click="runDatabaseDiagnostics"
+        >
+          {{ s__('DatabaseDiagnostics|Run Collation Check') }}
+        </gl-button>
+      </div>
+    </div>
+
+    <gl-alert v-if="isInitialLoad" variant="info" data-testid="loading-alert" :dismissible="false">
+      <gl-loading-icon size="sm" inline class="gl-mr-2" />
+      {{ s__('DatabaseDiagnostics|Checking for recent diagnostic results...') }}
+    </gl-alert>
+
+    <gl-alert v-if="isRunning" variant="info" data-testid="running-alert" :dismissible="false">
+      <gl-loading-icon size="sm" inline class="gl-mr-2" />
+      {{ s__('DatabaseDiagnostics|Running diagnostics...') }}
+    </gl-alert>
+
+    <gl-alert v-if="error" variant="danger" data-testid="error-alert" @dismiss="error = null">
+      {{ error }}
+    </gl-alert>
+
+    <!-- Results Section -->
+    <template v-if="hasResults && !isRunning">
+      <div
+        v-for="(dbResults, dbName) in results.databases"
+        :key="dbName"
+        class="gl-mt-4"
+        :data-testid="`database-${dbName}`"
+      >
+        <h3 class="gl-heading-5">
+          {{ sprintf(s__('DatabaseDiagnostics|Database: %{name}'), { name: dbName }) }}
+        </h3>
+
+        <!-- Collation Mismatches Section -->
+        <gl-card class="gl-mt-3" data-testid="collation-mismatches-section">
+          <template #header>
+            <div class="gl-display-flex gl-align-items-center">
+              <gl-icon
+                :name="hasMismatches(dbResults) ? 'information-o' : 'check-circle-filled'"
+                :variant="hasMismatches(dbResults) ? 'info' : 'success'"
+                class="gl-mr-2"
+                data-testid="collation-mismatches-icon"
+              />
+              <strong>{{ __('Collation Mismatches') }}</strong>
+            </div>
+          </template>
+
+          <template v-if="hasMismatches(dbResults)">
+            <gl-alert
+              variant="info"
+              data-testid="collation-info-alert"
+              :dismissible="false"
+              class="gl-mb-3"
+            >
+              {{
+                s__(
+                  'DatabaseDiagnostics|Collation mismatches are shown for informational purposes and may not indicate a problem.',
+                )
+              }}
+            </gl-alert>
+            <gl-table
+              :items="dbResults.collation_mismatches"
+              :fields="$options.collationMismatchFields"
+              bordered
+              striped
+              stacked="sm"
+              data-testid="collation-mismatches-table"
+            />
+          </template>
+          <template v-else>
+            <gl-alert
+              variant="success"
+              data-testid="no-collation-mismatches-alert"
+              :dismissible="false"
+            >
+              {{ __('No collation mismatches detected.') }}
+            </gl-alert>
+          </template>
+        </gl-card>
+
+        <!-- Corrupted Indexes Section -->
+        <gl-card class="gl-mt-3" data-testid="corrupted-indexes-section">
+          <template #header>
+            <div class="gl-display-flex gl-align-items-center">
+              <gl-icon
+                :name="hasCorruptedIndexes(dbResults) ? 'error' : 'check-circle-filled'"
+                :variant="hasCorruptedIndexes(dbResults) ? 'danger' : 'success'"
+                class="gl-mr-2"
+                data-testid="corrupted-indexes-icon"
+              />
+              <strong>{{ __('Corrupted Indexes') }}</strong>
+              <gl-badge
+                v-if="hasCorruptedIndexes(dbResults)"
+                variant="danger"
+                class="gl-ml-2"
+                data-testid="corrupted-indexes-count"
+              >
+                {{ dbResults.corrupted_indexes.length }}
+              </gl-badge>
+            </div>
+          </template>
+
+          <template v-if="hasCorruptedIndexes(dbResults)">
+            <gl-table
+              :items="dbResults.corrupted_indexes"
+              :fields="$options.corruptedIndexesFields"
+              bordered
+              striped
+              stacked="sm"
+              data-testid="corrupted-indexes-table"
+            >
+              <template #cell(index_type)="{ value }">
+                {{ value }}
+              </template>
+
+              <template #cell(is_unique)="{ value }">
+                {{ value ? __('Yes') : __('No') }}
+              </template>
+
+              <template #cell(size)="{ item }">
+                {{ formatBytes(item.size_bytes) }}
+              </template>
+
+              <template #cell(corruption_types)="{ value }">
+                <gl-badge
+                  v-for="type in value"
+                  :key="type"
+                  :variant="type === 'structural' ? 'danger' : 'warning'"
+                  class="gl-mr-2"
+                  :data-testid="`corruption-type-${type}`"
+                >
+                  {{ type === 'structural' ? __('Structural') : __('Duplicates') }}
+                </gl-badge>
+              </template>
+            </gl-table>
+          </template>
+          <template v-else>
+            <gl-alert
+              variant="success"
+              data-testid="no-corrupted-indexes-alert"
+              :dismissible="false"
+            >
+              {{ __('No corrupted indexes detected.') }}
+            </gl-alert>
+          </template>
+        </gl-card>
+      </div>
+
+      <!-- Action Card -->
+      <gl-card v-if="hasIssues" class="gl-mt-5" data-testid="action-card">
+        <template #header>
+          <div class="gl-display-flex gl-align-items-center">
+            <gl-icon name="information-o" class="gl-mr-2" />
+            <strong>{{ s__('DatabaseDiagnostics|Issues detected') }}</strong>
+          </div>
+        </template>
+
+        <p>
+          {{
+            s__(
+              'DatabaseDiagnostics|These issues require manual remediation. Read our documentation on PostgreSQL OS upgrades for step-by-step instructions.',
+            )
+          }}
+        </p>
+
+        <div class="gl-display-flex gl-flex-wrap gl-gap-3">
+          <gl-button
+            :href="documentationUrl"
+            target="_blank"
+            icon="document"
+            category="primary"
+            variant="confirm"
+            data-testid="learn-more-button"
+          >
+            {{ s__('DatabaseDiagnostics|Learn more') }}
+          </gl-button>
+
+          <gl-button
+            :href="$options.supportUrl"
+            target="_blank"
+            icon="support"
+            category="secondary"
+            data-testid="contact-support-button"
+          >
+            {{ s__('DatabaseDiagnostics|Contact Support') }}
+          </gl-button>
+        </div>
+      </gl-card>
+    </template>
+
+    <!-- No Results Yet Message -->
+    <gl-alert
+      v-if="shouldShowNoResultsMessage"
+      variant="info"
+      data-testid="no-results-message"
+      :dismissible="false"
+    >
+      {{
+        s__(
+          'DatabaseDiagnostics|No diagnostics have been run yet. Click "Run Collation Check" to analyze your database for potential collation issues.',
+        )
+      }}
+    </gl-alert>
+  </div>
+</template>
diff --git a/app/assets/javascripts/admin/database_diagnostics/components/combined_diagnostics.vue b/app/assets/javascripts/admin/database_diagnostics/components/combined_diagnostics.vue
new file mode 100644
index 0000000000000000000000000000000000000000..29795a5d1b4a9592f6427ecd61adcc2edd0225a0
--- /dev/null
+++ b/app/assets/javascripts/admin/database_diagnostics/components/combined_diagnostics.vue
@@ -0,0 +1,38 @@
+<script>
+import CollationChecker from './collation_checker.vue';
+import SchemaChecker from './schema_checker.vue';
+
+export default {
+  components: {
+    CollationChecker,
+    SchemaChecker,
+  },
+  props: {
+    runCollationCheckUrl: String,
+    collationCheckResultsUrl: String,
+    runSchemaCheckUrl: String,
+    schemaCheckResultsUrl: String
+  }
+};
+</script>
+
+// combined_diagnostics.vue
+<template>
+  <div class="diagnostics-container">
+    <div class="diagnostics-section">
+      <h2>Database Collation Checker</h2>
+      <CollationChecker
+        :runCollationCheckUrl="runCollationCheckUrl"
+        :collationCheckResultsUrl="collationCheckResultsUrl"
+      />
+    </div>
+
+    <div class="diagnostics-section">
+      <h2>Database Schema Checker</h2>
+      <SchemaChecker
+        :runSchemaCheckUrl="runSchemaCheckUrl"
+        :schemaCheckResultsUrl="schemaCheckResultsUrl"
+      />
+    </div>
+  </div>
+</template>
diff --git a/app/assets/javascripts/admin/database_diagnostics/components/schema_checker.vue b/app/assets/javascripts/admin/database_diagnostics/components/schema_checker.vue
new file mode 100644
index 0000000000000000000000000000000000000000..10aa2ca383f9858896659af6b12381ade2701e9b
--- /dev/null
+++ b/app/assets/javascripts/admin/database_diagnostics/components/schema_checker.vue
@@ -0,0 +1,241 @@
+<script>
+import { GlAlert, GlButton } from '@gitlab/ui';
+import axios from '~/lib/utils/axios_utils';
+import { __, s__ } from '~/locale';
+import { formatDate } from '~/lib/utils/datetime_utility';
+import SchemaSection from './schema_section.vue';
+
+const I18N = {
+  title: s__('DatabaseDiagnostics|Schema Health Check'),
+  description: s__(
+    'DatabaseDiagnostics|Detect database schema inconsistencies and structural issues',
+  ),
+  runButton: s__('DatabaseDiagnostics|Run Schema Check'),
+  lastRun: s__('DatabaseDiagnostics|Last checked: %{timestamp}'),
+  loading: s__('DatabaseDiagnostics|Running diagnostics...'),
+  noResultsText: s__(
+    'DatabaseDiagnostics|No diagnostics have been run yet. Click "Run Schema Check" to analyze your database schema.',
+  ),
+  indexes: s__('DatabaseDiagnostics|Indexes'),
+  tables: s__('DatabaseDiagnostics|Tables'),
+  foreignKeys: s__('DatabaseDiagnostics|Foreign Keys'),
+  sequences: s__('DatabaseDiagnostics|Sequences'),
+};
+
+export default {
+  name: 'SchemaChecker',
+  i18n: I18N,
+  components: {
+    GlAlert,
+    GlButton,
+    SchemaSection,
+  },
+  props: {
+    runSchemaCheckUrl: {
+      type: String,
+      required: true,
+    },
+    schemaCheckResultsUrl: {
+      type: String,
+      required: true,
+    },
+  },
+  data() {
+    return {
+      isLoading: false,
+      isRunning: false,
+      results: null,
+      error: null,
+      pollingId: null,
+      expandedSections: {
+        indexes: false,
+        tables: false,
+        foreignKeys: false,
+        sequences: false,
+      },
+    };
+  },
+  computed: {
+    formattedLastRunAt() {
+      return this.results?.metadata?.last_run_at
+        ? formatDate(new Date(this.results.metadata.last_run_at))
+        : '';
+    },
+    hasResults() {
+      return this.results !== null;
+    },
+    sections() {
+      return [
+        {
+          key: 'indexes',
+          title: this.$options.i18n.indexes,
+          issues: {
+            missing: this.results?.missing_indexes || [],
+            extra: this.results?.extra_indexes || [],
+            invalid: this.results?.invalid_indexes || [],
+            duplicate: this.results?.duplicate_indexes || [],
+          },
+        },
+        {
+          key: 'tables',
+          title: this.$options.i18n.tables,
+          issues: {
+            missing: this.results?.missing_tables || [],
+            extra: this.results?.extra_tables || [],
+            inconsistent: this.results?.inconsistent_tables || [],
+          },
+        },
+        {
+          key: 'foreignKeys',
+          title: this.$options.i18n.foreignKeys,
+          issues: {
+            missing: this.results?.missing_foreign_keys || [],
+            extra: this.results?.extra_foreign_keys || [],
+            invalid: this.results?.invalid_foreign_keys || [],
+          },
+        },
+        {
+          key: 'sequences',
+          title: this.$options.i18n.sequences,
+          issues: {
+            missing: this.results?.missing_sequences || [],
+            extra: this.results?.extra_sequences || [],
+            inconsistent: this.results?.inconsistent_sequences || [],
+          },
+        },
+      ];
+    },
+  },
+  created() {
+    // Try to fetch results on component creation
+    this.fetchResults();
+  },
+  beforeDestroy() {
+    this.stopPolling();
+  },
+  methods: {
+    async fetchResults() {
+      try {
+        const { data } = await axios.get(this.schemaCheckResultsUrl);
+        if (data) {
+          this.results = data?.schema_check_results?.main;
+        }
+      } catch (error) {
+        this.error =
+          error.response?.data?.message || __('An error occurred while fetching results');
+      }
+    },
+
+    async runDatabaseDiagnostics() {
+      this.isLoading = true;
+      this.isRunning = true;
+      this.error = null;
+
+      try {
+        await axios.post(this.runSchemaCheckUrl);
+        this.startPolling();
+      } catch (error) {
+        this.isLoading = false;
+        this.isRunning = false;
+        this.error =
+          error.response?.data?.message || __('An error occurred while starting diagnostics');
+      }
+    },
+
+    startPolling() {
+      this.pollingId = setInterval(() => {
+        this.pollResults();
+      }, 2000); // Poll every 2 seconds
+    },
+
+    stopPolling() {
+      if (this.pollingId) {
+        clearInterval(this.pollingId);
+        this.pollingId = null;
+      }
+    },
+
+    async pollResults() {
+      try {
+        const { data } = await axios.get(this.schemaCheckResultsUrl);
+
+        if (data) {
+          this.results = data;
+          this.isLoading = false;
+          this.isRunning = false;
+          this.stopPolling();
+        }
+      } catch (error) {
+        this.isLoading = false;
+        this.isRunning = false;
+        this.stopPolling();
+        this.error =
+          error.response?.data?.message || __('An error occurred while fetching results');
+      }
+    },
+
+    toggleSection(sectionKey) {
+      this.expandedSections[sectionKey] = !this.expandedSections[sectionKey];
+    },
+  },
+};
+</script>
+
+<template>
+  <div class="gl-mt-3">
+    <div class="gl-display-flex gl-justify-content-between gl-mb-5 gl-flex-wrap gl-gap-3">
+      <div>
+        <h4>{{ $options.i18n.title }}</h4>
+        <p class="gl-text-secondary">
+          {{ $options.i18n.description }}
+          <small v-if="results?.metadata?.last_run_at" class="gl-ml-2">
+            {{ $options.i18n.lastRun.replace('%{timestamp}', formattedLastRunAt) }}
+          </small>
+        </p>
+      </div>
+      <div>
+        <gl-button
+          variant="confirm"
+          :disabled="isLoading || isRunning"
+          data-testid="run-diagnostics-button"
+          @click="runDatabaseDiagnostics"
+        >
+          {{ $options.i18n.runButton }}
+        </gl-button>
+      </div>
+    </div>
+
+    <gl-alert v-if="isRunning" variant="info" :dismissible="false">
+      <gl-loading-icon size="sm" inline class="gl-mr-2" />
+      {{ $options.i18n.loading }}
+    </gl-alert>
+
+    <gl-alert v-if="error" variant="danger" @dismiss="error = null">
+      {{ error }}
+    </gl-alert>
+
+    <!-- Results Section -->
+    <template v-if="hasResults && !isRunning">
+      <schema-section
+        v-for="section in sections"
+        :key="section.key"
+        :title="section.title"
+        :section-key="section.key"
+        :issues="section.issues"
+        :is-expanded="expandedSections[section.key]"
+        @toggle="toggleSection"
+      />
+    </template>
+
+    <!-- No Results Yet Message -->
+    <gl-alert
+      v-if="!hasResults && !isRunning"
+      variant="info"
+      class="gl-mt-3"
+      :dismissible="false"
+      data-testid="no-results-message"
+    >
+      {{ $options.i18n.noResultsText }}
+    </gl-alert>
+  </div>
+</template>
diff --git a/app/assets/javascripts/admin/database_diagnostics/components/schema_section.vue b/app/assets/javascripts/admin/database_diagnostics/components/schema_section.vue
new file mode 100644
index 0000000000000000000000000000000000000000..44d6a1d07ede1e4d776d0f649a946f20675a8dc7
--- /dev/null
+++ b/app/assets/javascripts/admin/database_diagnostics/components/schema_section.vue
@@ -0,0 +1,178 @@
+<script>
+import { GlAlert, GlButton, GlCard, GlIcon, GlBadge } from '@gitlab/ui';
+import { s__ } from '~/locale';
+
+const I18N = {
+  details: s__('DatabaseDiagnostics|Details'),
+  noIssuesDetected: s__('DatabaseDiagnostics|No issues detected.'),
+  missing: s__('DatabaseDiagnostics|Missing'),
+  extra: s__('DatabaseDiagnostics|Extra'),
+  invalid: s__('DatabaseDiagnostics|Invalid'),
+  inconsistent: s__('DatabaseDiagnostics|Inconsistent'),
+};
+
+const CATEGORY_CONFIG = {
+  missing: {
+    icon: 'warning',
+    variant: 'warning',
+    bgClass: 'gl-bg-orange-50',
+  },
+  extra: {
+    icon: 'information-o',
+    variant: 'info',
+    bgClass: 'gl-bg-blue-50',
+  },
+  invalid: {
+    icon: 'error',
+    variant: 'danger',
+    bgClass: 'gl-bg-red-50',
+  },
+  inconsistent: {
+    icon: 'warning-solid',
+    variant: 'warning',
+    bgClass: 'gl-bg-orange-50',
+  },
+};
+
+export default {
+  name: 'SchemaSection',
+  i18n: I18N,
+  components: {
+    GlAlert,
+    GlButton,
+    GlCard,
+    GlIcon,
+    GlBadge,
+  },
+  props: {
+    title: {
+      type: String,
+      required: true,
+    },
+    sectionKey: {
+      type: String,
+      required: true,
+    },
+    issues: {
+      type: [Array, Object],
+      default: () => ({}),
+    },
+    isExpanded: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  computed: {
+    // Convert legacy array format to categorized format for backward compatibility
+    categorizedIssues() {
+      if (Array.isArray(this.issues)) {
+        return { missing: this.issues };
+      }
+      return this.issues || {};
+    },
+    hasIssues() {
+      return Object.values(this.categorizedIssues).some(
+        (categoryIssues) => Array.isArray(categoryIssues) && categoryIssues.length > 0,
+      );
+    },
+    totalIssueCount() {
+      return Object.values(this.categorizedIssues).reduce((total, categoryIssues) => {
+        return total + (Array.isArray(categoryIssues) ? categoryIssues.length : 0);
+      }, 0);
+    },
+    iconStatus() {
+      return {
+        icon: this.hasIssues ? 'warning' : 'check-circle-filled',
+        variant: this.hasIssues ? 'warning' : 'success',
+      };
+    },
+    issueCategories() {
+      return Object.entries(this.categorizedIssues)
+        .filter(([, issues]) => Array.isArray(issues) && issues.length > 0)
+        .map(([category, issues]) => ({
+          key: category,
+          name: this.$options.i18n[category] || category,
+          issues,
+          config: CATEGORY_CONFIG[category] || CATEGORY_CONFIG.missing,
+        }));
+    },
+  },
+  methods: {
+    toggleSection() {
+      this.$emit('toggle', this.sectionKey);
+    },
+  },
+};
+</script>
+
+<template>
+  <gl-card class="gl-mt-3">
+    <template #header>
+      <div class="gl-display-flex gl-align-items-center gl-justify-content-between">
+        <div class="gl-display-flex gl-align-items-center">
+          <gl-icon :name="iconStatus.icon" :variant="iconStatus.variant" class="gl-mr-2" />
+          <strong>{{ title }}</strong>
+          <gl-badge v-if="hasIssues" variant="warning" class="gl-ml-2">
+            {{ totalIssueCount }}
+          </gl-badge>
+        </div>
+        <gl-button
+          v-if="hasIssues"
+          category="tertiary"
+          size="md"
+          class="gl-m-2 gl-px-3 gl-py-2"
+          @click="toggleSection"
+        >
+          <gl-icon :name="isExpanded ? 'chevron-up' : 'chevron-down'" :size="16" class="gl-mr-2" />
+          {{ $options.i18n.details }}
+        </gl-button>
+      </div>
+    </template>
+
+    <!-- Show categorized issues when expanded -->
+    <div v-if="isExpanded && hasIssues" class="gl-p-3">
+      <div v-for="category in issueCategories" :key="category.key" class="gl-mb-4 last:gl-mb-0">
+        <!-- Category Header -->
+        <div class="gl-display-flex gl-align-items-center gl-mb-2">
+          <gl-icon
+            :name="category.config.icon"
+            :variant="category.config.variant"
+            :size="14"
+            class="gl-mr-2"
+          />
+          <strong class="gl-text-sm gl-text-gray-700">{{ category.name }}</strong>
+          <gl-badge :variant="category.config.variant" size="sm" class="gl-ml-2">
+            {{ category.issues.length }}
+          </gl-badge>
+        </div>
+
+        <!-- Category Issues -->
+        <div
+          :class="[
+            'gl-rounded-base gl-border-1 gl-border-solid gl-border-gray-200 gl-p-3',
+            category.config.bgClass,
+          ]"
+        >
+          <div
+            v-for="(issue, index) in category.issues"
+            :key="index"
+            class="gl-display-flex gl-align-items-start gl-mb-2 gl-text-sm last:gl-mb-0"
+          >
+            <gl-icon
+              :name="category.config.icon"
+              :variant="category.config.variant"
+              :size="12"
+              class="gl-mr-2 gl-mt-1 gl-flex-shrink-0"
+            />
+            <span class="gl-flex-grow-1">{{ issue }}</span>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Show success message when no issues -->
+    <gl-alert v-else-if="!hasIssues" variant="success" :dismissible="false">
+      {{ $options.i18n.noIssuesDetected }}
+    </gl-alert>
+  </gl-card>
+</template>
diff --git a/app/assets/javascripts/admin/database_diagnostics/index.js b/app/assets/javascripts/admin/database_diagnostics/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..b51ef312e195eb555369f253a81c97e379e0ca09
--- /dev/null
+++ b/app/assets/javascripts/admin/database_diagnostics/index.js
@@ -0,0 +1,26 @@
+import Vue from 'vue';
+import CombinedDiagnostics from './components/combined_diagnostics.vue';
+
+export const initDatabaseDiagnosticsApp = () => {
+  const el = document.getElementById('js-database-diagnostics');
+
+  if (!el) {
+    return false;
+  }
+
+  const { runCollationCheckUrl, collationCheckResultsUrl, runSchemaCheckUrl, schemaCheckResultsUrl } = el.dataset;
+
+  return new Vue({
+    el,
+    render(h) {
+      return h(CombinedDiagnostics, {
+        props: {
+          runCollationCheckUrl,
+          collationCheckResultsUrl,
+          runSchemaCheckUrl,
+          schemaCheckResultsUrl
+        },
+      });
+    },
+  });
+};
diff --git a/app/assets/javascripts/pages/admin/database_diagnostics/index.js b/app/assets/javascripts/pages/admin/database_diagnostics/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..9a35ceb8b5d028b0f583d1e5000358275d826fdc
--- /dev/null
+++ b/app/assets/javascripts/pages/admin/database_diagnostics/index.js
@@ -0,0 +1,3 @@
+import { initDatabaseDiagnosticsApp } from '~/admin/database_diagnostics';
+
+initDatabaseDiagnosticsApp();
diff --git a/app/controllers/admin/database_diagnostics_controller.rb b/app/controllers/admin/database_diagnostics_controller.rb
new file mode 100644
index 0000000000000000000000000000000000000000..f843ec59b0589cddf0685f5c98343fb654aeac71
--- /dev/null
+++ b/app/controllers/admin/database_diagnostics_controller.rb
@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Admin
+  class DatabaseDiagnosticsController < Admin::ApplicationController
+    feature_category :database
+    authorize! :read_admin_database_diagnostics,
+      only: %i[index run_collation_check collation_check_results run_schema_check schema_check_results]
+
+    def index
+      # Just render the view
+    end
+
+    def run_collation_check
+      job_id = ::Database::CollationCheckerWorker.perform_async # rubocop:disable CodeReuse/Worker -- Simple direct call
+
+      render json: { status: 'scheduled', job_id: job_id }
+    end
+
+    def run_schema_check
+      Database::SchemaCheckerWorker.perform_async # rubocop:disable CodeReuse/Worker -- Simple direct call
+
+      respond_to do |format|
+        format.json { render json: { status: 'scheduled' } }
+      end
+    end
+
+    def schema_check_results
+      result = Rails.cache.read(Database::SchemaCheckerWorker::SCHEMA_CHECK_CACHE_KEY)
+
+      render json: result
+    end
+
+    def collation_check_results
+      results_json = Rails.cache.read(::Database::CollationCheckerWorker::COLLATION_CHECK_CACHE_KEY)
+
+      if results_json.present?
+        results = Gitlab::Json.parse(results_json)
+        render json: results
+      else
+        render json: { error: 'No results available yet' }, status: :not_found
+      end
+    end
+  end
+end
diff --git a/app/policies/global_policy.rb b/app/policies/global_policy.rb
index 9430882e93a01b982a4f48d9436967fdbf016b97..2bd723dfa05e40e947c3250dd91c4ab6c50e28ef 100644
--- a/app/policies/global_policy.rb
+++ b/app/policies/global_policy.rb
@@ -159,6 +159,7 @@ class GlobalPolicy < BasePolicy
     enable :read_admin_cicd
     enable :read_admin_gitaly_servers
     enable :read_admin_health_check
+    enable :read_admin_database_diagnostics
     enable :read_admin_metrics_dashboard
     enable :read_admin_system_information
     enable :read_admin_users
diff --git a/app/views/admin/database_diagnostics/index.html.haml b/app/views/admin/database_diagnostics/index.html.haml
new file mode 100644
index 0000000000000000000000000000000000000000..8d7269cef68729a0988fc17634d6306f4c13d801
--- /dev/null
+++ b/app/views/admin/database_diagnostics/index.html.haml
@@ -0,0 +1,17 @@
+- page_title _('Database Diagnostics')
+
+%section.settings.monitoring
+  .settings-header
+    %h1
+      = _('Database Diagnostics')
+    %p
+      = _('Tools for detecting and resolving database issues in self-managed GitLab instances.')
+
+#js-database-diagnostics{
+  data: {
+    run_collation_check_url: run_collation_check_admin_database_diagnostics_path(format: :json),
+    collation_check_results_url: collation_check_results_admin_database_diagnostics_path(format: :json),
+    run_schema_check_url: run_schema_check_admin_database_diagnostics_path(format: :json),
+    schema_check_results_url: schema_check_results_admin_database_diagnostics_path(format: :json)
+  }
+}
diff --git a/config/routes/admin.rb b/config/routes/admin.rb
index 7b74b6609e555431481a6229594d0a3312421eea..a810279dfc664ebc596dced1b534b3ae751b898f 100644
--- a/config/routes/admin.rb
+++ b/config/routes/admin.rb
@@ -120,6 +120,14 @@
 
   resource :health_check, controller: 'health_check', only: [:show]
   resource :background_jobs, controller: 'background_jobs', only: [:show]
+  resources :database_diagnostics, controller: 'database_diagnostics', only: [:index] do
+    collection do
+      post :run_collation_check
+      get :collation_check_results
+      post :run_schema_check
+      get :schema_check_results
+    end
+  end
 
   resource :system_info, controller: 'system_info', only: [:show]
 
diff --git a/lib/sidebars/admin/menus/monitoring_menu.rb b/lib/sidebars/admin/menus/monitoring_menu.rb
index 94f8bf5daeb5aa86e90223c72e02c72a942303cd..d361dc620e4a3de270174c335c4087700f07bd96 100644
--- a/lib/sidebars/admin/menus/monitoring_menu.rb
+++ b/lib/sidebars/admin/menus/monitoring_menu.rb
@@ -10,6 +10,7 @@ def configure_menu_items
           add_item(background_migrations_menu_item)
           add_item(background_jobs_menu_item)
           add_item(health_check_menu_item)
+          add_item(database_diagnostics_menu_item)
           add_item(metrics_dashboard_menu_item)
           true
         end
@@ -67,6 +68,15 @@ def health_check_menu_item
           ) { can?(current_user, :read_admin_health_check) }
         end
 
+        def database_diagnostics_menu_item
+          build_menu_item(
+            title: _('Database diagnostics'),
+            link: admin_database_diagnostics_path,
+            active_routes: { controller: 'database_diagnostics' },
+            item_id: :database_diagnostics
+          ) { can?(current_user, :read_admin_database_diagnostics) }
+        end
+
         def metrics_dashboard_menu_item
           build_menu_item(
             title: _('Metrics Dashboard'),
diff --git a/locale/gitlab.pot b/locale/gitlab.pot
index 4e9ede9ea06f13a360285acf6db6c9558ae71a99..bf2cbcead79017a572dda64b4a0b5f24d27ea1af 100644
--- a/locale/gitlab.pot
+++ b/locale/gitlab.pot
@@ -3688,6 +3688,9 @@ msgstr ""
 msgid "Activity|An error occurred while retrieving activity. Reload the page to try again."
 msgstr ""
 
+msgid "Actual Version"
+msgstr ""
+
 msgid "Add"
 msgstr ""
 
@@ -5939,6 +5942,9 @@ msgstr ""
 msgid "AdvancedSearch|You have pending obsolete migrations"
 msgstr ""
 
+msgid "Affected Columns"
+msgstr ""
+
 msgid "After it is removed, the fork relationship can only be restored by using the API. This project will no longer be able to receive or send merge requests to the upstream project or other forks."
 msgstr ""
 
@@ -7431,6 +7437,9 @@ msgstr ""
 msgid "An error occurred while fetching reference"
 msgstr ""
 
+msgid "An error occurred while fetching results"
+msgstr ""
+
 msgid "An error occurred while fetching reviewers."
 msgstr ""
 
@@ -7587,6 +7596,9 @@ msgstr ""
 msgid "An error occurred while searching for labels, please try again."
 msgstr ""
 
+msgid "An error occurred while starting diagnostics"
+msgstr ""
+
 msgid "An error occurred while subscribing to this page. Please try again later."
 msgstr ""
 
@@ -15269,6 +15281,12 @@ msgstr ""
 msgid "Collapse sidebar"
 msgstr ""
 
+msgid "Collation Mismatches"
+msgstr ""
+
+msgid "Collation Name"
+msgstr ""
+
 msgid "Collector hostname"
 msgstr ""
 
@@ -18894,6 +18912,9 @@ msgstr ""
 msgid "Correlation ID"
 msgstr ""
 
+msgid "Corrupted Indexes"
+msgstr ""
+
 msgid "Cost Factor Settings"
 msgstr ""
 
@@ -21241,9 +21262,87 @@ msgstr ""
 msgid "Database '%{database_name}' is using PostgreSQL %{pg_version_current}, but this version of GitLab requires PostgreSQL %{pg_version_minimum}. Please upgrade your environment to a supported PostgreSQL version. See %{pg_requirements_url} for details."
 msgstr ""
 
+msgid "Database Diagnostics"
+msgstr ""
+
+msgid "Database diagnostics"
+msgstr ""
+
 msgid "Database update failed"
 msgstr ""
 
+msgid "DatabaseDiagnostics|Checking for recent diagnostic results..."
+msgstr ""
+
+msgid "DatabaseDiagnostics|Collation Health Check"
+msgstr ""
+
+msgid "DatabaseDiagnostics|Collation mismatches are shown for informational purposes and may not indicate a problem."
+msgstr ""
+
+msgid "DatabaseDiagnostics|Contact Support"
+msgstr ""
+
+msgid "DatabaseDiagnostics|Database: %{name}"
+msgstr ""
+
+msgid "DatabaseDiagnostics|Details"
+msgstr ""
+
+msgid "DatabaseDiagnostics|Detect collation-related index corruption issues that may occur after OS upgrades"
+msgstr ""
+
+msgid "DatabaseDiagnostics|Detect database schema inconsistencies and structural issues"
+msgstr ""
+
+msgid "DatabaseDiagnostics|Foreign Keys"
+msgstr ""
+
+msgid "DatabaseDiagnostics|Indexes"
+msgstr ""
+
+msgid "DatabaseDiagnostics|Issues detected"
+msgstr ""
+
+msgid "DatabaseDiagnostics|Last checked: %{timestamp}"
+msgstr ""
+
+msgid "DatabaseDiagnostics|Learn more"
+msgstr ""
+
+msgid "DatabaseDiagnostics|No diagnostics have been run yet. Click \"Run Collation Check\" to analyze your database for potential collation issues."
+msgstr ""
+
+msgid "DatabaseDiagnostics|No diagnostics have been run yet. Click \"Run Schema Check\" to analyze your database schema."
+msgstr ""
+
+msgid "DatabaseDiagnostics|No issues detected."
+msgstr ""
+
+msgid "DatabaseDiagnostics|Run Collation Check"
+msgstr ""
+
+msgid "DatabaseDiagnostics|Run Schema Check"
+msgstr ""
+
+msgid "DatabaseDiagnostics|Running diagnostics..."
+msgstr ""
+
+msgid "DatabaseDiagnostics|Schema Health Check"
+msgstr ""
+
+msgid "DatabaseDiagnostics|Sequences"
+msgstr ""
+
+msgid "DatabaseDiagnostics|Tables"
+msgstr ""
+
+msgid "DatabaseDiagnostics|The database diagnostic job is taking longer than expected. You can check back later or try running it again."
+msgstr ""
+
+msgid "DatabaseDiagnostics|These issues require manual remediation. Read our documentation on PostgreSQL OS upgrades for step-by-step instructions."
+msgstr ""
+
 msgid "DatadogIntegration|%{link_start}API key%{link_end} used for authentication with Datadog."
 msgstr ""
 
@@ -24346,6 +24445,9 @@ msgstr ""
 msgid "Duplicate page: A page with that title already exists in the file %{file}"
 msgstr ""
 
+msgid "Duplicates"
+msgstr ""
+
 msgid "Duration"
 msgstr ""
 
@@ -33511,6 +33613,9 @@ msgstr ""
 msgid "Index"
 msgstr ""
 
+msgid "Index Name"
+msgstr ""
+
 msgid "Index deletion is canceled"
 msgstr ""
 
@@ -41693,6 +41798,9 @@ msgstr ""
 msgid "No child items are currently assigned."
 msgstr ""
 
+msgid "No collation mismatches detected."
+msgstr ""
+
 msgid "No comment templates found."
 msgstr ""
 
@@ -41723,6 +41831,9 @@ msgstr ""
 msgid "No contributions were found"
 msgstr ""
 
+msgid "No corrupted indexes detected."
+msgstr ""
+
 msgid "No credit card data for matching"
 msgstr ""
 
@@ -61496,12 +61607,18 @@ msgstr ""
 msgid "StorageSize|Unknown"
 msgstr ""
 
+msgid "Stored Version"
+msgstr ""
+
 msgid "Strikethrough (%{modifierKey}%{shiftKey}X)"
 msgstr ""
 
 msgid "Strikethrough text"
 msgstr ""
 
+msgid "Structural"
+msgstr ""
+
 msgid "Sub-batch size"
 msgstr ""
 
@@ -62267,6 +62384,9 @@ msgstr ""
 msgid "TXT"
 msgstr ""
 
+msgid "Table"
+msgstr ""
+
 msgid "Table of contents"
 msgstr ""
 
@@ -65947,6 +66067,9 @@ msgstr ""
 msgid "ToolCoverage|Project coverage"
 msgstr ""
 
+msgid "Tools for detecting and resolving database issues in self-managed GitLab instances."
+msgstr ""
+
 msgid "Topic %{source_topic} was successfully merged into topic %{target_topic}."
 msgstr ""
 
@@ -66888,6 +67011,9 @@ msgstr ""
 msgid "Unhelpful or irrelevant"
 msgstr ""
 
+msgid "Unique"
+msgstr ""
+
 msgid "Unique identifier for the target chat or the username of the target channel (in the format `@channelusername`)."
 msgstr ""
 
diff --git a/spec/frontend/admin/database_diagnostics/components/collation_checker_spec.js b/spec/frontend/admin/database_diagnostics/components/collation_checker_spec.js
new file mode 100644
index 0000000000000000000000000000000000000000..e7c6d3a6922323485f565ccc4535ff1f03941568
--- /dev/null
+++ b/spec/frontend/admin/database_diagnostics/components/collation_checker_spec.js
@@ -0,0 +1,300 @@
+import { nextTick } from 'vue';
+import { GlLoadingIcon } from '@gitlab/ui';
+import MockAdapter from 'axios-mock-adapter';
+import { shallowMountExtended } from 'helpers/vue_test_utils_helper';
+import axios from '~/lib/utils/axios_utils';
+import waitForPromises from 'helpers/wait_for_promises';
+import CollationChecker from '~/admin/database_diagnostics/components/collation_checker.vue';
+
+describe('CollationChecker component', () => {
+  let wrapper;
+  let mockAxios;
+
+  // Set shorter polling values for tests to keep them fast
+  const TEST_POLLING_INTERVAL_MS = 50;
+  const TEST_MAX_POLLING_ATTEMPTS = 2;
+
+  const findTitle = () => wrapper.findByTestId('title');
+  const findRunButton = () => wrapper.findByTestId('run-diagnostics-button');
+  const findLoadingAlert = () => wrapper.findByTestId('loading-alert');
+  const findRunningAlert = () => wrapper.findByTestId('running-alert');
+  const findErrorAlert = () => wrapper.findByTestId('error-alert');
+  const findNoResultsMessage = () => wrapper.findByTestId('no-results-message');
+
+  // Database sections
+  const findDatabaseMain = () => wrapper.findByTestId('database-main');
+  const findDatabaseCI = () => wrapper.findByTestId('database-ci');
+
+  // Other sections
+  const findCollationInfoAlert = () => wrapper.findByTestId('collation-info-alert');
+  const findCorruptedIndexesTable = () => wrapper.findByTestId('corrupted-indexes-table');
+  const findNoCollationMismatchesAlert = () =>
+    wrapper.findByTestId('no-collation-mismatches-alert');
+  const findNoCorruptedIndexesAlert = () => wrapper.findByTestId('no-corrupted-indexes-alert');
+
+  // Action card
+  const findActionCard = () => wrapper.findByTestId('action-card');
+  const findLearnMoreButton = () => wrapper.findByTestId('learn-more-button');
+  const findContactSupportButton = () => wrapper.findByTestId('contact-support-button');
+
+  const createComponent = (props = {}) => {
+    wrapper = shallowMountExtended(CollationChecker, {
+      propsData: {
+        runCollationCheckUrl: '/admin/database_diagnostics/run_collation_check.json',
+        collationCheckResultsUrl: '/admin/database_diagnostics/collation_check_results.json',
+        pollingIntervalMs: TEST_POLLING_INTERVAL_MS,
+        maxPollingAttempts: TEST_MAX_POLLING_ATTEMPTS,
+        ...props,
+      },
+    });
+  };
+
+  const clickRunButton = async () => {
+    findRunButton().vm.$emit('click');
+    await nextTick();
+  };
+
+  const collationMismatchResults = {
+    metadata: {
+      last_run_at: '2025-07-23T10:00:00Z',
+    },
+    databases: {
+      main: {
+        collation_mismatches: [
+          {
+            collation_name: 'en_US.UTF-8',
+            provider: 'c',
+            stored_version: '2.28',
+            actual_version: '2.31',
+          },
+        ],
+        corrupted_indexes: [
+          {
+            index_name: 'index_users_on_name',
+            table_name: 'users',
+            affected_columns: 'name',
+            index_type: 'btree',
+            is_unique: true,
+            size_bytes: 5678901,
+            corruption_types: ['duplicates'],
+            needs_deduplication: true,
+          },
+        ],
+      },
+      ci: {
+        collation_mismatches: [],
+        corrupted_indexes: [],
+      },
+    },
+  };
+
+  const noIssuesResults = {
+    metadata: {
+      last_run_at: '2025-07-23T10:00:00Z',
+    },
+    databases: {
+      main: {
+        collation_mismatches: [],
+        corrupted_indexes: [],
+      },
+    },
+  };
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    mockAxios = new MockAdapter(axios);
+  });
+
+  afterEach(() => {
+    mockAxios.restore();
+    jest.clearAllTimers();
+  });
+
+  describe('initial state', () => {
+    beforeEach(() => {
+      mockAxios.onGet('/admin/database_diagnostics/collation_check_results.json').reply(404);
+      createComponent();
+    });
+
+    it('shows a loading indicator initially', () => {
+      expect(findLoadingAlert().exists()).toBe(true);
+      expect(findLoadingAlert().findComponent(GlLoadingIcon).exists()).toBe(true);
+    });
+
+    it('renders the title', async () => {
+      await waitForPromises();
+
+      expect(findTitle().exists()).toBe(true);
+    });
+
+    it('shows no results message after loading', async () => {
+      mockAxios.onGet('/admin/database_diagnostics/collation_check_results.json').reply(404);
+      createComponent();
+      await waitForPromises();
+
+      expect(findLoadingAlert().exists()).toBe(false);
+      expect(findNoResultsMessage().exists()).toBe(true);
+    });
+
+    it('enables the run button after loading completes', async () => {
+      expect(findRunButton().props('disabled')).toBe(true);
+
+      await waitForPromises();
+
+      expect(findRunButton().props('disabled')).toBe(false);
+    });
+  });
+
+  describe('with results showing collation mismatches', () => {
+    beforeEach(async () => {
+      mockAxios
+        .onGet('/admin/database_diagnostics/collation_check_results.json')
+        .reply(200, collationMismatchResults);
+      createComponent();
+      await waitForPromises();
+    });
+
+    it('renders both database sections', () => {
+      expect(findDatabaseMain().exists()).toBe(true);
+      expect(findDatabaseCI().exists()).toBe(true);
+    });
+
+    it('displays collation mismatches alert', () => {
+      expect(findCollationInfoAlert().exists()).toBe(true);
+    });
+
+    it('displays corrupted indexes table', () => {
+      expect(findCorruptedIndexesTable().exists()).toBe(true);
+    });
+
+    it('displays action card with remediation links', () => {
+      expect(findActionCard().exists()).toBe(true);
+      expect(findLearnMoreButton().exists()).toBe(true);
+      expect(findContactSupportButton().exists()).toBe(true);
+    });
+  });
+
+  describe('with no issues', () => {
+    beforeEach(async () => {
+      mockAxios
+        .onGet('/admin/database_diagnostics/collation_check_results.json')
+        .reply(200, noIssuesResults);
+      createComponent();
+      await waitForPromises();
+    });
+
+    it('shows success alerts for no mismatches and no corrupted indexes', () => {
+      expect(findNoCollationMismatchesAlert().exists()).toBe(true);
+      expect(findNoCorruptedIndexesAlert().exists()).toBe(true);
+    });
+
+    it('does not display the action card', () => {
+      expect(findActionCard().exists()).toBe(false);
+    });
+  });
+
+  describe('running diagnostics', () => {
+    beforeEach(async () => {
+      // Initial load - no results
+      mockAxios.onGet('/admin/database_diagnostics/collation_check_results.json').reply(404);
+      mockAxios.onPost('/admin/database_diagnostics/run_collation_check.json').reply(200);
+      createComponent();
+      await waitForPromises();
+    });
+
+    it('shows loading state and disables button when run button is clicked', async () => {
+      await clickRunButton();
+
+      expect(findRunButton().props('disabled')).toBe(true);
+
+      await waitForPromises();
+
+      expect(findRunningAlert().exists()).toBe(true);
+      expect(findRunButton().props('disabled')).toBe(true);
+    });
+
+    it('makes the correct API call when run button is clicked', async () => {
+      await clickRunButton();
+      await waitForPromises();
+
+      expect(mockAxios.history.post).toHaveLength(1);
+      expect(mockAxios.history.post[0].url).toBe(
+        '/admin/database_diagnostics/run_collation_check.json',
+      );
+    });
+
+    it('updates the view when results are available after polling', async () => {
+      await clickRunButton();
+      await waitForPromises();
+
+      expect(findRunningAlert().exists()).toBe(true);
+
+      mockAxios
+        .onGet('/admin/database_diagnostics/collation_check_results.json')
+        .reply(200, collationMismatchResults);
+
+      jest.advanceTimersByTime(TEST_POLLING_INTERVAL_MS);
+      await nextTick();
+      await waitForPromises();
+
+      expect(findRunningAlert().exists()).toBe(false);
+      expect(findDatabaseMain().exists()).toBe(true);
+    });
+  });
+
+  describe('error handling', () => {
+    it('displays error alert when initial API request fails', async () => {
+      mockAxios.onGet('/admin/database_diagnostics/collation_check_results.json').reply(500, {
+        error: 'Internal server error',
+      });
+
+      createComponent();
+      await waitForPromises();
+
+      expect(findErrorAlert().exists()).toBe(true);
+      expect(findErrorAlert().text()).toContain('Internal server error');
+    });
+
+    it('displays error alert when run diagnostic request fails', async () => {
+      mockAxios.onGet('/admin/database_diagnostics/collation_check_results.json').reply(404);
+      mockAxios.onPost('/admin/database_diagnostics/run_collation_check.json').reply(500, {
+        error: 'Failed to schedule diagnostics',
+      });
+
+      createComponent();
+      await waitForPromises();
+
+      await clickRunButton();
+      await waitForPromises();
+
+      expect(findErrorAlert().exists()).toBe(true);
+      expect(findErrorAlert().text()).toContain('Failed to schedule diagnostics');
+    });
+  });
+
+  describe('polling', () => {
+    it('stops polling after reaching the maximum attempts', async () => {
+      // Set up API mocks
+      mockAxios.onGet('/admin/database_diagnostics/collation_check_results.json').reply(404);
+      mockAxios.onPost('/admin/database_diagnostics/run_collation_check.json').reply(200);
+
+      createComponent();
+      await waitForPromises();
+
+      // Use our custom helper to simulate user clicking the button
+      await clickRunButton();
+      await waitForPromises();
+
+      // Verify initial state
+      expect(findRunningAlert().exists()).toBe(true);
+
+      await jest.advanceTimersByTime(TEST_POLLING_INTERVAL_MS * TEST_MAX_POLLING_ATTEMPTS);
+      await waitForPromises();
+
+      // Verify polling has stopped and error is shown
+      expect(findRunningAlert().exists()).toBe(false);
+      expect(findErrorAlert().exists()).toBe(true);
+      expect(findErrorAlert().text()).toContain('taking longer than expected');
+    });
+  });
+});
diff --git a/spec/policies/global_policy_spec.rb b/spec/policies/global_policy_spec.rb
index 1685cc42b28d9d08ea374efaf94f0432c25bbe95..1bb19c79b26d1923399c38768ecffee2f50630db 100644
--- a/spec/policies/global_policy_spec.rb
+++ b/spec/policies/global_policy_spec.rb
@@ -752,18 +752,19 @@
       let(:permissions) do
         [
           :access_admin_area,
-          :read_application_statistics,
-          :read_admin_users,
-          :read_admin_groups,
-          :read_admin_projects,
           :read_admin_audit_log,
           :read_admin_background_jobs,
           :read_admin_background_migrations,
           :read_admin_cicd,
+          :read_admin_database_diagnostics,
           :read_admin_gitaly_servers,
+          :read_admin_groups,
           :read_admin_health_check,
           :read_admin_metrics_dashboard,
-          :read_admin_system_information
+          :read_admin_projects,
+          :read_admin_system_information,
+          :read_admin_users,
+          :read_application_statistics
         ]
       end
 
diff --git a/spec/requests/admin/database_diagnostics_controller_spec.rb b/spec/requests/admin/database_diagnostics_controller_spec.rb
new file mode 100644
index 0000000000000000000000000000000000000000..871c4bdf2f4ce894a1dd5b71e58781bcd19e56c5
--- /dev/null
+++ b/spec/requests/admin/database_diagnostics_controller_spec.rb
@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Admin::DatabaseDiagnostics', feature_category: :database do
+  include AdminModeHelper
+
+  let_it_be(:admin) { create(:admin) }
+  let_it_be(:user) { create(:user) }
+
+  shared_examples 'unauthorized request' do
+    context 'when user is not an admin' do
+      before do
+        login_as(user)
+      end
+
+      it 'returns 404 response' do
+        send_request
+
+        expect(response).to have_gitlab_http_status(:not_found)
+      end
+    end
+
+    context 'when admin mode is disabled' do
+      before do
+        login_as(admin)
+      end
+
+      it 'redirects to admin mode enable' do
+        send_request
+
+        expect(response).to redirect_to(new_admin_session_path)
+      end
+    end
+  end
+
+  describe 'GET /admin/database_diagnostics' do
+    subject(:send_request) do
+      get admin_database_diagnostics_path
+    end
+
+    it_behaves_like 'unauthorized request'
+
+    context 'when admin mode is enabled', :enable_admin_mode do
+      before do
+        login_as(admin)
+      end
+
+      it 'returns 200 response' do
+        send_request
+
+        expect(response).to have_gitlab_http_status(:ok)
+      end
+    end
+  end
+
+  describe 'POST /admin/database_diagnostics/run_collation_check' do
+    subject(:send_request) do
+      post run_collation_check_admin_database_diagnostics_path(format: :json)
+    end
+
+    it_behaves_like 'unauthorized request'
+
+    context 'when admin mode is enabled', :enable_admin_mode do
+      before do
+        login_as(admin)
+      end
+
+      it 'returns 200 response and schedules the worker' do
+        expect(::Database::CollationCheckerWorker).to receive(:perform_async).and_return('job_id')
+
+        send_request
+
+        expect(response).to have_gitlab_http_status(:ok)
+        expect(json_response).to include('status' => 'scheduled', 'job_id' => 'job_id')
+      end
+    end
+  end
+
+  describe 'GET /admin/database_diagnostics/collation_check_results' do
+    subject(:send_request) do
+      get collation_check_results_admin_database_diagnostics_path(format: :json)
+    end
+
+    it_behaves_like 'unauthorized request'
+
+    context 'when admin mode is enabled', :enable_admin_mode do
+      before do
+        login_as(admin)
+      end
+
+      context 'when results are available' do
+        let(:results) do
+          {
+            metadata: { last_run_at: Time.current.iso8601 },
+            databases: {
+              main: {
+                collation_mismatches: [],
+                corrupted_indexes: []
+              }
+            }
+          }
+        end
+
+        it 'returns 200 response with the results' do
+          allow(Rails.cache).to receive(:read)
+          expect(Rails.cache).to receive(:read)
+            .with(::Database::CollationCheckerWorker::COLLATION_CHECK_CACHE_KEY)
+            .and_return(results.to_json)
+
+          send_request
+
+          expect(response).to have_gitlab_http_status(:ok)
+          expect(json_response).to include('metadata', 'databases')
+        end
+      end
+
+      context 'when no results are available' do
+        it 'returns 404 response' do
+          send_request
+
+          expect(response).to have_gitlab_http_status(:not_found)
+          expect(json_response).to include('error' => 'No results available yet')
+        end
+      end
+    end
+  end
+end