diff --git a/src/components/characterization-results/RawResultTable.vue b/src/components/characterization-results/RawResultTable.vue
new file mode 100644
index 00000000..1a96aabd
--- /dev/null
+++ b/src/components/characterization-results/RawResultTable.vue
@@ -0,0 +1,195 @@
+<!--
+  RawResultTable
+
+  Renders result rows that the mapper could not classify as prevalence or
+  distribution — typically the output of a custom-SQL feature analysis that
+  emits its own columns. Rather than dropping such rows, we show them
+  verbatim: columns are derived dynamically from whatever keys the rows
+  carry, so a spec-conformant custom SQL is always at least visible.
+
+  This is intentionally a plain, shape-agnostic fallback. Purpose-built
+  visualisations for categorical / series / cross-tab outputs come later;
+  the contract this table honours is simply "never make custom output
+  invisible".
+-->
+<template>
+  <AtlasCard
+    padding="none"
+    class="raw-result-table"
+    :data-testid="`char-results-raw-${analysisId}`"
+  >
+    <div class="raw-result-table__header">
+      <div class="raw-result-table__eyebrow-row">
+        <span class="text-eyebrow">{{ analysisName }}</span>
+        <span class="raw-result-table__accent-rule" />
+      </div>
+      <h3 class="raw-result-table__title">
+        {{ tv('characterizations.results.table.raw', 'Custom output') }}
+        <span class="raw-result-table__count">({{ rows.length }})</span>
+        <span
+          v-if="hasCustomFe"
+          class="raw-result-table__badge"
+          :title="tv('characterizations.results.table.customFeHint',
+                     'Produced by a custom-SQL feature analysis')"
+        >
+          {{ tv('characterizations.results.table.customFe', 'Custom SQL') }}
+        </span>
+      </h3>
+    </div>
+
+    <AtlasDataTable
+      :items="tableRows"
+      :headers="headers"
+      :items-per-page="25"
+      :items-per-page-options="[10, 25, 50, 100, -1]"
+      class="raw-result-table__table"
+      :data-testid="`char-results-raw-table-${analysisId}`"
+    />
+  </AtlasCard>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue'
+
+import { useI18n } from '@/composables/useI18n'
+import { AtlasCard, AtlasDataTable } from '@/components/ui'
+
+interface Props {
+  analysisId: number
+  analysisName: string
+  rows: Record<string, unknown>[]
+}
+
+const props = defineProps<Props>()
+const { tv } = useI18n()
+
+// Columns that live in the group header or are surfaced as a badge — hidden
+// from the table body to avoid noise.
+const HIDDEN_KEYS = new Set(['analysisId', 'analysisName', 'faType'])
+
+// Well-known columns get a stable leading order; unknown (custom) columns
+// follow, alphabetically, so the interesting bespoke output is easy to scan.
+const PREFERRED_ORDER = [
+  'covariateId',
+  'covariateName',
+  'covariateShortName',
+  'conceptId',
+  'conceptName',
+  'domainId',
+  'resultType',
+  'cohortId',
+  'cohortName',
+  'strataId',
+  'strataName',
+]
+
+const hasCustomFe = computed<boolean>(() =>
+  props.rows.some(r => r.faType === 'CUSTOM_FE')
+)
+
+const columnKeys = computed<string[]>(() => {
+  const seen = new Set<string>()
+  for (const row of props.rows) {
+    for (const key of Object.keys(row)) {
+      if (!HIDDEN_KEYS.has(key)) seen.add(key)
+    }
+  }
+  const preferred = PREFERRED_ORDER.filter(k => seen.has(k))
+  const rest = Array.from(seen)
+    .filter(k => !PREFERRED_ORDER.includes(k))
+    .sort((a, b) => a.localeCompare(b))
+  return [...preferred, ...rest]
+})
+
+const headers = computed(() =>
+  columnKeys.value.map(key => ({
+    title: humanize(key),
+    key,
+    align: 'start' as const,
+  }))
+)
+
+const tableRows = computed<Record<string, string | number>[]>(() =>
+  props.rows.map(row => {
+    const flat: Record<string, string | number> = {}
+    for (const key of columnKeys.value) {
+      flat[key] = formatValue(row[key])
+    }
+    return flat
+  })
+)
+
+function humanize(key: string): string {
+  const spaced = key.replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/[_-]+/g, ' ')
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1)
+}
+
+function formatValue(value: unknown): string | number {
+  if (value === null || value === undefined) return '—'
+  if (typeof value === 'number') {
+    return Number.isInteger(value) && Math.abs(value) >= 1000
+      ? value.toLocaleString()
+      : value
+  }
+  if (typeof value === 'string' || typeof value === 'boolean') return String(value)
+  try {
+    return JSON.stringify(value)
+  } catch {
+    return String(value)
+  }
+}
+</script>
+
+<style scoped>
+.raw-result-table {
+  margin-bottom: 16px;
+}
+
+.raw-result-table__header {
+  padding: 20px 20px 12px;
+}
+
+.raw-result-table__eyebrow-row {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-bottom: 6px;
+}
+
+.raw-result-table__accent-rule {
+  display: inline-block;
+  width: 28px;
+  height: 2px;
+  background-color: rgb(var(--v-theme-orange));
+  border-radius: 2px;
+}
+
+.raw-result-table__title {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  font-size: 18px;
+  font-weight: 500;
+  line-height: 1.3;
+  margin: 0;
+  color: rgb(var(--v-theme-primary));
+}
+
+.raw-result-table__count {
+  font-size: 0.85rem;
+  color: rgba(var(--v-theme-on-surface), 0.6);
+  font-weight: 400;
+}
+
+.raw-result-table__badge {
+  align-self: center;
+  font-size: 0.7rem;
+  font-weight: 600;
+  letter-spacing: 0.02em;
+  text-transform: uppercase;
+  padding: 2px 8px;
+  border-radius: 10px;
+  color: rgb(var(--v-theme-orange));
+  background: rgba(var(--v-theme-orange), 0.12);
+}
+</style>
diff --git a/src/components/characterization/CharacterizationPerAnalysisView.vue b/src/components/characterization/CharacterizationPerAnalysisView.vue
index 37bad1bb..7ebc161f 100644
--- a/src/components/characterization/CharacterizationPerAnalysisView.vue
+++ b/src/components/characterization/CharacterizationPerAnalysisView.vue
@@ -17,8 +17,16 @@
       :rows="g.rows"
       :cohorts="g.cohorts"
     />
+    <RawResultTable
+      v-for="g in unmappedGroups"
+      :key="`raw-${g.analysisId}`"
+      :analysis-id="g.analysisId"
+      :analysis-name="g.analysisName"
+      :rows="g.rows"
+    />
     <div
-      v-if="prevalenceGroups.length === 0 && distributionGroups.length === 0"
+      v-if="prevalenceGroups.length === 0 && distributionGroups.length === 0
+        && unmappedGroups.length === 0"
       class="char-per-analysis__empty"
     >
       {{ tv('common.noData', 'No rows match the current filter.') }}
@@ -31,6 +39,7 @@ import { computed } from 'vue'
 import { useI18n } from '@/composables/useI18n'
 import PrevalenceTable from '@/components/characterization-results/PrevalenceTable.vue'
 import DistributionTable from '@/components/characterization-results/DistributionTable.vue'
+import RawResultTable from '@/components/characterization-results/RawResultTable.vue'
 import { DEFAULT_STRATA_KEY } from '@/utils/characterization-result-mapper'
 import type {
   DistributionStat, LinkedCohort, PrevalenceStat,
@@ -39,6 +48,7 @@ import type {
 const props = defineProps<{
   prevalence: PrevalenceStat[]
   distribution: DistributionStat[]
+  unmapped?: Record<string, unknown>[]
   cohorts: LinkedCohort[]
   threshold: number
   selectedAnalysisIds: number[]
@@ -108,6 +118,28 @@ const distributionGroups = computed<Group<DistributionStat>[]>(() => {
   }
   return Array.from(groups.values())
 })
+
+interface RawGroup { analysisId: number; analysisName: string; rows: Record<string, unknown>[] }
+
+const unmappedGroups = computed<RawGroup[]>(() => {
+  const groups = new Map<number, RawGroup>()
+  for (const row of props.unmapped ?? []) {
+    const analysisId = typeof row.analysisId === 'number' ? row.analysisId : -1
+    if (!passesAnalysis(analysisId)) continue
+    const domainId = typeof row.domainId === 'string' ? row.domainId : undefined
+    if (!passesDomain(domainId)) continue
+    let g = groups.get(analysisId)
+    if (!g) {
+      const analysisName = typeof row.analysisName === 'string' && row.analysisName
+        ? row.analysisName
+        : `Analysis ${analysisId}`
+      g = { analysisId, analysisName, rows: [] }
+      groups.set(analysisId, g)
+    }
+    g.rows.push(row)
+  }
+  return Array.from(groups.values())
+})
 </script>
 
 <style scoped>
diff --git a/src/components/characterization/CharacterizationWorkbench.vue b/src/components/characterization/CharacterizationWorkbench.vue
index 3fffbd96..b568bb6d 100644
--- a/src/components/characterization/CharacterizationWorkbench.vue
+++ b/src/components/characterization/CharacterizationWorkbench.vue
@@ -97,6 +97,7 @@
             v-else
             :prevalence="prevalence"
             :distribution="distribution"
+            :unmapped="unmapped"
             :cohorts="cohorts"
             :threshold="filters.threshold"
             :selected-analysis-ids="filters.selectedAnalysisIds"
@@ -195,7 +196,7 @@ const { tv } = useI18n()
 const store = useCharacterizationStore()
 const sourcesStore = useDataSourcesStore()
 const cohortSizes = ref<Record<string, number>>({})
-const { execution, prevalence, distribution, resultCount, error, load, reset } = useCharacterizationResults()
+const { execution, prevalence, distribution, unmapped, resultCount, error, load, reset } = useCharacterizationResults()
 
 const railOpen = ref(!route.params.id)
 const viewMode = ref<ViewMode>('perAnalysis')
diff --git a/src/composables/useCharacterizationResults.ts b/src/composables/useCharacterizationResults.ts
index b74e7805..76fa2755 100644
--- a/src/composables/useCharacterizationResults.ts
+++ b/src/composables/useCharacterizationResults.ts
@@ -17,6 +17,7 @@ export function useCharacterizationResults() {
   const resultCount = ref<number>(0)
   const prevalence = ref<PrevalenceStat[]>([])
   const distribution = ref<DistributionStat[]>([])
+  const unmapped = ref<Record<string, unknown>[]>([])
   const loading = ref<boolean>(false)
   const error = ref<string | null>(null)
 
@@ -25,6 +26,7 @@ export function useCharacterizationResults() {
     resultCount.value = 0
     prevalence.value = []
     distribution.value = []
+    unmapped.value = []
     error.value = null
     loading.value = true
     try {
@@ -38,6 +40,7 @@ export function useCharacterizationResults() {
       resultCount.value = count
       prevalence.value = mapped.prevalence
       distribution.value = mapped.distribution
+      unmapped.value = mapped.unmapped
       return true
     } catch (err) {
       error.value = err instanceof Error ? err.message : 'Failed to load results'
@@ -53,9 +56,10 @@ export function useCharacterizationResults() {
     resultCount.value = 0
     prevalence.value = []
     distribution.value = []
+    unmapped.value = []
     error.value = null
     loading.value = false
   }
 
-  return { execution, resultCount, prevalence, distribution, loading, error, load, reset }
+  return { execution, resultCount, prevalence, distribution, unmapped, loading, error, load, reset }
 }
diff --git a/src/utils/characterization-result-mapper.ts b/src/utils/characterization-result-mapper.ts
index c4838eef..4876d38b 100644
--- a/src/utils/characterization-result-mapper.ts
+++ b/src/utils/characterization-result-mapper.ts
@@ -33,6 +33,14 @@ export type CharacterizationStatType = 'PREVALENCE' | 'DISTRIBUTION'
 export interface MappedCharacterizationResults {
   prevalence: PrevalenceStat[]
   distribution: DistributionStat[]
+  /**
+   * Rows the classifier could not fit into the prevalence / distribution
+   * shapes (e.g. custom-SQL feature analyses that emit their own columns).
+   * Instead of silently dropping them, we surface the raw records so the
+   * viewer can render them verbatim. Kept as loose records because the
+   * column set is, by definition, unknown here.
+   */
+  unmapped: Record<string, unknown>[]
 }
 
 /** Internal: a single raw row before classification. */
@@ -272,24 +280,27 @@ export function computeBinaryStdDiff(
 export function mapCharacterizationResults(raw: unknown[]): MappedCharacterizationResults {
   const prevalenceMap = new Map<string, PrevalenceStat>()
   const distributionMap = new Map<string, DistributionStat>()
+  const unmapped: Record<string, unknown>[] = []
   let skipped = 0
 
   for (const value of raw) {
     const rows = toRawRows(value)
     if (rows.length === 0) {
+      // Malformed row (missing analysisId/covariateId) — not a spec-conformant
+      // result row, so nothing meaningful to surface. Dropped as before.
       skipped++
       continue
     }
     for (const row of rows) {
       const type = classifyRow(row)
       if (type === null) {
-        skipped++
+        unmapped.push(row as Record<string, unknown>)
         continue
       }
       const groupKey = `${row.analysisId}::${row.covariateId}`
       const cKey = cohortKey(row)
       if (!cKey) {
-        skipped++
+        unmapped.push(row as Record<string, unknown>)
         continue
       }
       const sKey = strataKey(row)
@@ -353,11 +364,18 @@ export function mapCharacterizationResults(raw: unknown[]): MappedCharacterizati
   }
 
   if (skipped > 0) {
-    logger.debug('CharacterizationResultMapper', `Skipped ${skipped} unclassifiable result row(s)`)
+    logger.debug('CharacterizationResultMapper', `Skipped ${skipped} non-record result row(s)`)
+  }
+  if (unmapped.length > 0) {
+    logger.debug(
+      'CharacterizationResultMapper',
+      `Surfacing ${unmapped.length} unmapped result row(s) as raw output`
+    )
   }
 
   return {
     prevalence: Array.from(prevalenceMap.values()),
     distribution: Array.from(distributionMap.values()),
+    unmapped,
   }
 }
diff --git a/tests/component/characterization-results/RawResultTable.spec.ts b/tests/component/characterization-results/RawResultTable.spec.ts
new file mode 100644
index 00000000..100cd6db
--- /dev/null
+++ b/tests/component/characterization-results/RawResultTable.spec.ts
@@ -0,0 +1,96 @@
+/**
+ * RawResultTable component tests
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { mount } from '@vue/test-utils'
+import { createVuetify } from 'vuetify'
+import * as components from 'vuetify/components'
+import * as directives from 'vuetify/directives'
+import { createPinia, setActivePinia } from 'pinia'
+
+import RawResultTable from '@/components/characterization-results/RawResultTable.vue'
+
+vi.mock('@/composables/useI18n', async () => {
+  const { mockUseI18n } = await import('../../helpers/i18n-mock')
+  return mockUseI18n
+})
+
+const vuetify = createVuetify({ components, directives })
+
+global.ResizeObserver = vi.fn().mockImplementation(() => ({
+  observe: vi.fn(),
+  unobserve: vi.fn(),
+  disconnect: vi.fn(),
+}))
+
+function mountTable(rows: Record<string, unknown>[]) {
+  return mount(RawResultTable, {
+    props: { analysisId: 500, analysisName: 'Custom analysis', rows },
+    global: { plugins: [vuetify] },
+    attachTo: document.body,
+  })
+}
+
+describe('RawResultTable', () => {
+  beforeEach(() => {
+    document.body.innerHTML = ''
+    setActivePinia(createPinia())
+  })
+
+  it('derives columns from arbitrary custom-SQL keys', () => {
+    const wrapper = mountTable([
+      { covariateId: 1, covariateName: 'home death', deathPlace: 'home', deaths: 1280 },
+    ])
+    const headers = wrapper.findAll('th').map((h) => h.text())
+    // Well-known columns lead; bespoke columns are surfaced too.
+    expect(headers.some((h) => /Covariate Name/i.test(h))).toBe(true)
+    expect(headers.some((h) => /Death Place/i.test(h))).toBe(true)
+    expect(headers.some((h) => /Deaths/i.test(h))).toBe(true)
+    wrapper.unmount()
+  })
+
+  it('hides header/badge-only keys from the table body', () => {
+    const wrapper = mountTable([
+      { covariateId: 1, covariateName: 'x', analysisId: 500, analysisName: 'Custom analysis', faType: 'CUSTOM_FE' },
+    ])
+    const headers = wrapper.findAll('th').map((h) => h.text())
+    expect(headers.some((h) => /^Analysis Id$/i.test(h))).toBe(false)
+    expect(headers.some((h) => /Fa Type|faType/i.test(h))).toBe(false)
+    wrapper.unmount()
+  })
+
+  it('shows a Custom SQL badge when a row is CUSTOM_FE', () => {
+    const wrapper = mountTable([{ covariateId: 1, covariateName: 'x', faType: 'CUSTOM_FE' }])
+    expect(wrapper.text()).toMatch(/Custom SQL/i)
+    wrapper.unmount()
+  })
+
+  it('omits the badge when no row is CUSTOM_FE', () => {
+    const wrapper = mountTable([{ covariateId: 1, covariateName: 'x', faType: 'PRESET' }])
+    expect(wrapper.find('.raw-result-table__badge').exists()).toBe(false)
+    wrapper.unmount()
+  })
+
+  it('formats large integers, nullish, boolean and object values', () => {
+    const circular: Record<string, unknown> = {}
+    circular.self = circular
+    const wrapper = mountTable([
+      {
+        covariateId: 1,
+        bigCount: 1234567, // integer >= 1000 → localized with separators
+        smallCount: 42, // left as a number
+        missing: null, // → em dash
+        flag: true, // → "true"
+        payload: { a: 1 }, // → JSON string
+        cyclic: circular, // JSON.stringify throws → String() fallback
+      },
+    ])
+    const text = wrapper.text()
+    expect(text).toContain((1234567).toLocaleString())
+    expect(text).toContain('—')
+    expect(text).toContain('true')
+    expect(text).toContain('{"a":1}')
+    expect(text).toContain('[object Object]')
+    wrapper.unmount()
+  })
+})
diff --git a/tests/component/characterization/CharacterizationPerAnalysisView.spec.ts b/tests/component/characterization/CharacterizationPerAnalysisView.spec.ts
index b43bf2e5..a2935ecf 100644
--- a/tests/component/characterization/CharacterizationPerAnalysisView.spec.ts
+++ b/tests/component/characterization/CharacterizationPerAnalysisView.spec.ts
@@ -38,4 +38,71 @@ describe('CharacterizationPerAnalysisView', () => {
     const tables = w.findAllComponents({ name: 'PrevalenceTable' })
     expect(tables).toHaveLength(2)
   })
+
+  function mountWithUnmapped(
+    unmapped: Record<string, unknown>[],
+    overrides: Record<string, unknown> = {}
+  ) {
+    return mount(CharacterizationPerAnalysisView, {
+      global: {
+        plugins: [vuetify],
+        stubs: ['PrevalenceTable', 'DistributionTable', 'RawResultTable'],
+      },
+      props: {
+        prevalence: [],
+        distribution: [],
+        unmapped,
+        cohorts: COHORTS,
+        threshold: 0,
+        selectedAnalysisIds: [],
+        selectedDomains: [],
+        selectedCohortId: null,
+        ...overrides,
+      },
+    })
+  }
+
+  it('renders a RawResultTable per unmapped analysis group', () => {
+    const w = mountWithUnmapped([
+      { analysisId: 10, analysisName: 'Death place', covariateId: 1, deaths: 5 },
+      { analysisId: 10, analysisName: 'Death place', covariateId: 2, deaths: 7 },
+      { analysisId: 20, analysisName: 'Weekday', covariateId: 3, admits: 9 },
+    ])
+    const tables = w.findAllComponents({ name: 'RawResultTable' })
+    expect(tables).toHaveLength(2)
+    // Rows collapse into their analysisId group.
+    const first = tables.find((t) => t.props('analysisId') === 10)
+    expect(first?.props('rows')).toHaveLength(2)
+  })
+
+  it('falls back to a synthetic analysis name/id for rows without analysisId', () => {
+    const w = mountWithUnmapped([{ covariateId: 1, value: 3 }])
+    const table = w.findComponent({ name: 'RawResultTable' })
+    expect(table.props('analysisId')).toBe(-1)
+    expect(table.props('analysisName')).toBe('Analysis -1')
+  })
+
+  it('applies the analysis and domain filters to unmapped rows', () => {
+    const rows = [
+      { analysisId: 10, covariateId: 1, domainId: 'DEATH', v: 1 },
+      { analysisId: 20, covariateId: 2, domainId: 'VISIT', v: 2 },
+    ]
+    // Analysis filter keeps only analysis 10.
+    const byAnalysis = mountWithUnmapped(rows, { selectedAnalysisIds: [10] })
+    let tables = byAnalysis.findAllComponents({ name: 'RawResultTable' })
+    expect(tables).toHaveLength(1)
+    expect(tables[0].props('analysisId')).toBe(10)
+
+    // Domain filter keeps only the VISIT row.
+    const byDomain = mountWithUnmapped(rows, { selectedDomains: ['VISIT'] })
+    tables = byDomain.findAllComponents({ name: 'RawResultTable' })
+    expect(tables).toHaveLength(1)
+    expect(tables[0].props('analysisId')).toBe(20)
+  })
+
+  it('shows the empty state when nothing (including unmapped) matches', () => {
+    const w = mountWithUnmapped([])
+    expect(w.findComponent({ name: 'RawResultTable' }).exists()).toBe(false)
+    expect(w.find('.char-per-analysis__empty').exists()).toBe(true)
+  })
 })
diff --git a/tests/unit/utils/characterization-result-mapper.spec.ts b/tests/unit/utils/characterization-result-mapper.spec.ts
index 3eb314e6..cd5d71a8 100644
--- a/tests/unit/utils/characterization-result-mapper.spec.ts
+++ b/tests/unit/utils/characterization-result-mapper.spec.ts
@@ -169,6 +169,62 @@ describe('mapCharacterizationResults', () => {
     expect(out.prevalence[0].count.M['1']).toBe(5)
     expect(out.prevalence[0].count.F['1']).toBe(7)
   })
+
+  it('surfaces classifiable-less rows with valid ids as unmapped', () => {
+    const raw = [
+      {
+        analysisId: 500,
+        analysisName: 'Days home vs hospital death',
+        covariateId: 9001,
+        covariateName: 'home death',
+        faType: 'CUSTOM_FE',
+        cohortId: 1,
+        // no count/pct/avg/median/… — a custom-SQL shape the classifier
+        // cannot fit into prevalence or distribution.
+        deathPlace: 'home',
+        deaths: 128,
+      },
+    ]
+    const out = mapCharacterizationResults(raw)
+    expect(out.prevalence).toEqual([])
+    expect(out.distribution).toEqual([])
+    expect(out.unmapped).toHaveLength(1)
+    expect(out.unmapped[0]).toMatchObject({
+      analysisId: 500,
+      faType: 'CUSTOM_FE',
+      deathPlace: 'home',
+      deaths: 128,
+    })
+  })
+
+  it('surfaces a classifiable row with no cohortId as unmapped', () => {
+    const out = mapCharacterizationResults([
+      {
+        analysisId: 1,
+        covariateId: 100,
+        covariateName: 'X',
+        conceptId: 100,
+        // classifiable as prevalence (has count/pct) but no cohortId to key by
+        count: 5,
+        pct: 5,
+      },
+    ])
+    expect(out.prevalence).toEqual([])
+    expect(out.distribution).toEqual([])
+    expect(out.unmapped).toHaveLength(1)
+    expect(out.unmapped[0]).toMatchObject({ analysisId: 1, covariateId: 100 })
+  })
+
+  it('does not surface malformed id-less rows as unmapped', () => {
+    const out = mapCharacterizationResults([{ foo: 'bar' }, null, { analysisId: 1 }])
+    expect(out.prevalence).toEqual([])
+    expect(out.distribution).toEqual([])
+    expect(out.unmapped).toEqual([])
+  })
+
+  it('includes an empty unmapped array by default', () => {
+    expect(mapCharacterizationResults([]).unmapped).toEqual([])
+  })
 })
 
 describe('computeBinaryStdDiff', () => {