diff --git a/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteContent/CommandPaletteContent.test.tsx b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteContent/CommandPaletteContent.test.tsx
index 24ff12352c..4cb111d3ce 100644
--- a/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteContent/CommandPaletteContent.test.tsx
+++ b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteContent/CommandPaletteContent.test.tsx
@@ -17,8 +17,40 @@ import { CommandPaletteContent } from './CommandPaletteContent'
 const schema: SchemaProviderValue = {
   current: {
     tables: {
-      users: aTable({ name: 'users' }),
-      posts: aTable({ name: 'posts' }),
+      users: aTable({
+        name: 'users',
+        columns: {
+          id: {
+            name: 'id',
+            type: 'bigint',
+            default: null,
+            check: null,
+            notNull: true,
+            comment: null,
+          },
+          name: {
+            name: 'name',
+            type: 'text',
+            default: null,
+            check: null,
+            notNull: true,
+            comment: null,
+          },
+        },
+      }),
+      posts: aTable({
+        name: 'posts',
+        columns: {
+          created_at: {
+            name: 'created_at',
+            type: 'timestamp',
+            default: null,
+            check: null,
+            notNull: true,
+            comment: null,
+          },
+        },
+      }),
       follows: aTable({ name: 'follows' }),
       user_settings: aTable({ name: 'user_settings' }),
     },
@@ -175,6 +207,41 @@ describe('input mode and filters', () => {
       ).toBeInTheDocument()
     })
   })
+
+  describe('table input mode', () => {
+    it('renders selected table option and its column options', async () => {
+      const user = userEvent.setup()
+      render(<CommandPaletteContent isTableModeActivatable />, { wrapper })
+
+      // switch to "table" input mode of the "users" table
+      await user.keyboard('users')
+      await user.keyboard('{Tab}')
+
+      // the "users" table option is always displayed on the top of the options list
+      expect(screen.getByRole('option', { name: 'users' })).toBeInTheDocument()
+      // column options of the "users" table
+      expect(screen.getByRole('option', { name: 'id' })).toBeInTheDocument()
+      expect(screen.getByRole('option', { name: 'name' })).toBeInTheDocument()
+    })
+
+    it('filters column options by user input in the combobox while keeping the selected table option visible', async () => {
+      const user = userEvent.setup()
+      render(<CommandPaletteContent isTableModeActivatable />, { wrapper })
+
+      // switch to "table" input mode of the "users" table
+      await user.keyboard('users')
+      await user.keyboard('{Tab}')
+      // filter the column options by typing "name"
+      await user.keyboard('name')
+
+      expect(screen.getByRole('option', { name: 'users' })).toBeInTheDocument()
+      expect(screen.getByRole('option', { name: 'name' })).toBeInTheDocument()
+      // the "id" column option is filtered out
+      expect(
+        screen.queryByRole('option', { name: 'id' }),
+      ).not.toBeInTheDocument()
+    })
+  })
 })
 
 describe('preview', () => {
@@ -192,6 +259,29 @@ describe('preview', () => {
       await user.hover(screen.getByRole('option', { name: 'posts' }))
       expect(within(previewContainer).getByText('posts')).toBeInTheDocument()
     })
+
+    it('renders a table preview when a column option is selected', async () => {
+      const user = userEvent.setup()
+      render(<CommandPaletteContent isTableModeActivatable />, { wrapper })
+      const previewContainer = screen.getByTestId('CommandPalettePreview')
+
+      // renders the "users" preview when the "users/name" option is selected
+      await user.hover(screen.getByRole('option', { name: 'users' }))
+      // go to the "table" input mode of the "users" table
+      await user.keyboard('{Tab}')
+      await user.hover(screen.getByRole('option', { name: 'name' }))
+      expect(within(previewContainer).getByText('users')).toBeInTheDocument()
+
+      // back to the "default" input mode
+      await user.keyboard('{Backspace}')
+
+      // renders the "posts" preview when the "posts/created_at" option is selected
+      await user.hover(screen.getByRole('option', { name: 'posts' }))
+      // go to the "table" input mode of the "posts" table
+      await user.keyboard('{Tab}')
+      await user.hover(screen.getByRole('option', { name: 'created_at' }))
+      expect(within(previewContainer).getByText('posts')).toBeInTheDocument()
+    })
   })
 
   describe('command preview', () => {
diff --git a/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteContent/CommandPaletteContent.tsx b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteContent/CommandPaletteContent.tsx
index 7808c05445..0591b442d0 100644
--- a/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteContent/CommandPaletteContent.tsx
+++ b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteContent/CommandPaletteContent.tsx
@@ -1,31 +1,68 @@
 import { Button } from '@liam-hq/ui'
 import { DialogClose } from '@radix-ui/react-dialog'
-import { Command, defaultFilter } from 'cmdk'
+import { Command, defaultFilter as cmdkBaseFilter } from 'cmdk'
 import { type FC, useMemo, useState } from 'react'
 import {
   CommandPaletteCommandOptions,
   TableOptions,
 } from '../CommandPaletteOptions'
+import { TableColumnOptions } from '../CommandPaletteOptions/TableColumnOptions'
 import { CommandPreview, TablePreview } from '../CommandPalettePreview'
 import { CommandPaletteSearchInput } from '../CommandPaletteSearchInput'
 import type { CommandPaletteInputMode } from '../types'
 import { textToSuggestion } from '../utils'
 import styles from './CommandPaletteContent.module.css'
 
-const commandPaletteFilter: typeof defaultFilter = (value, ...rest) => {
+const defaultCommandPaletteFilter: typeof cmdkBaseFilter = (value, ...rest) => {
   const suggestion = textToSuggestion(value)
 
   // if the value is inappropriate for suggestion, it returns 0 and the options is hidden
   // https://github.com/pacocoursey/cmdk/blob/d6fde235386414196bf80d9b9fa91e2cf89a72ea/cmdk/src/index.tsx#L91-L95
   if (!suggestion) return 0
 
-  return defaultFilter(suggestion.name, ...rest)
+  // displays 'table' and 'command' type suggestions in the "default" input mode
+  if (suggestion.type === 'table' || suggestion.type === 'command') {
+    return cmdkBaseFilter(suggestion.name, ...rest)
+  }
+
+  return 0
+}
+
+const tableInputModeFilter: typeof cmdkBaseFilter = (value, ...rest) => {
+  const suggestion = textToSuggestion(value)
+
+  // if the value is inappropriate for suggestion, it returns 0 and the options is hidden
+  // https://github.com/pacocoursey/cmdk/blob/d6fde235386414196bf80d9b9fa91e2cf89a72ea/cmdk/src/index.tsx#L91-L95
+  if (!suggestion) return 0
+
+  // always display the table itself on the top of the options list
+  if (suggestion.type === 'table') return 1
+  if (suggestion.type === 'column')
+    return cmdkBaseFilter(suggestion.columnName, ...rest)
+
+  // it displays only 'table' and 'column' type suggestions in the "table" input mode
+  return 0
 }
 
-export const CommandPaletteContent: FC = () => {
+type Props = {
+  isTableModeActivatable?: boolean
+}
+
+export const CommandPaletteContent: FC<Props> = ({
+  isTableModeActivatable = false,
+}) => {
   const [inputMode, setInputMode] = useState<CommandPaletteInputMode>({
     type: 'default',
   })
+  const filter = useMemo(() => {
+    switch (inputMode.type) {
+      case 'default':
+      case 'command':
+        return defaultCommandPaletteFilter
+      case 'table':
+        return tableInputModeFilter
+    }
+  }, [inputMode.type])
 
   const [suggestionText, setSuggestionText] = useState('')
   const suggestion = useMemo(
@@ -37,7 +74,7 @@ export const CommandPaletteContent: FC = () => {
     <Command
       value={suggestionText}
       onValueChange={(v) => setSuggestionText(v)}
-      filter={commandPaletteFilter}
+      filter={filter}
     >
       <div className={styles.searchContainer}>
         <CommandPaletteSearchInput
@@ -45,6 +82,7 @@ export const CommandPaletteContent: FC = () => {
           suggestion={suggestion}
           setMode={setInputMode}
           onBlur={(event) => event.target.focus()}
+          isTableModeActivatable={isTableModeActivatable}
         />
         <DialogClose asChild>
           <Button
@@ -62,6 +100,12 @@ export const CommandPaletteContent: FC = () => {
           {inputMode.type === 'default' && (
             <TableOptions suggestion={suggestion} />
           )}
+          {inputMode.type === 'table' && (
+            <TableColumnOptions
+              tableName={inputMode.tableName}
+              suggestion={suggestion}
+            />
+          )}
           {(inputMode.type === 'default' || inputMode.type === 'command') && (
             <CommandPaletteCommandOptions />
           )}
@@ -73,6 +117,9 @@ export const CommandPaletteContent: FC = () => {
           {suggestion?.type === 'table' && (
             <TablePreview tableName={suggestion.name} />
           )}
+          {suggestion?.type === 'column' && (
+            <TablePreview tableName={suggestion.tableName} />
+          )}
           {suggestion?.type === 'command' && (
             <CommandPreview commandName={suggestion.name} />
           )}
diff --git a/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteOptions/CommandPaletteOptions.module.css b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteOptions/CommandPaletteOptions.module.css
index 1e803848fe..0a0ebb0584 100644
--- a/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteOptions/CommandPaletteOptions.module.css
+++ b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteOptions/CommandPaletteOptions.module.css
@@ -6,6 +6,21 @@
   border-radius: var(--border-radius-base);
 }
 
+.item.indent {
+  padding-left: var(--spacing-6);
+  position: relative;
+}
+
+.item.indent:before {
+  content: '';
+  position: absolute;
+  top: calc(var(--spacing-1) / 2);
+  left: var(--spacing-4);
+  width: 1px;
+  height: calc(100% - var(--spacing-1));
+  background-color: var(--overlay-10);
+}
+
 .item .itemText {
   flex-grow: 1;
   font-size: var(--font-size-5);
diff --git a/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteOptions/TableColumnOptions.tsx b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteOptions/TableColumnOptions.tsx
new file mode 100644
index 0000000000..683fb3c037
--- /dev/null
+++ b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteOptions/TableColumnOptions.tsx
@@ -0,0 +1,180 @@
+import {
+  DiamondFillIcon,
+  DiamondIcon,
+  KeyRound,
+  Link,
+  Table2,
+} from '@liam-hq/ui'
+import clsx from 'clsx'
+import { Command } from 'cmdk'
+import {
+  type ComponentProps,
+  type FC,
+  useCallback,
+  useEffect,
+  useMemo,
+} from 'react'
+import {
+  getTableColumnElementId,
+  getTableColumnLinkHref,
+  getTableLinkHref,
+} from '../../../../../../features'
+import { useSchemaOrThrow } from '../../../../../../stores'
+import { useTableSelection } from '../../../../hooks'
+import { useCommandPaletteOrThrow } from '../CommandPaletteProvider'
+import type { CommandPaletteSuggestion } from '../types'
+import { getSuggestionText } from '../utils'
+import styles from './CommandPaletteOptions.module.css'
+import { type ColumnType, getColumnTypeMap } from './utils/getColumnTypeMap'
+
+type Props = {
+  tableName: string
+  suggestion: CommandPaletteSuggestion | null
+}
+
+const ColumnIcon: FC<ComponentProps<'svg'> & { columnType: ColumnType }> = ({
+  columnType,
+  ...props
+}) => {
+  switch (columnType) {
+    case 'PRIMARY_KEY':
+      return <KeyRound {...props} />
+    case 'FOREIGN_KEY':
+      return <Link {...props} />
+    case 'NOT_NULL':
+      return <DiamondFillIcon aria-label={undefined} {...props} />
+    case 'NULLABLE':
+      return <DiamondIcon aria-label={undefined} {...props} />
+  }
+}
+
+export const TableColumnOptions: FC<Props> = ({ tableName, suggestion }) => {
+  const schema = useSchemaOrThrow()
+  const { selectTable } = useTableSelection()
+  const { setOpen } = useCommandPaletteOrThrow()
+
+  const goToERD = useCallback(
+    (tableName: string, columnName?: string) => {
+      selectTable({ tableId: tableName, displayArea: 'main' })
+      setOpen(false)
+      if (columnName) {
+        window.location.hash = getTableColumnElementId(tableName, columnName)
+      }
+    },
+    [setOpen, selectTable],
+  )
+
+  // Select option by pressing [Enter] key (with/without ⌘ key)
+  useEffect(() => {
+    // It doesn't subscribe a keydown event listener if the suggestion type is not "table"
+    if (suggestion?.type !== 'table') return
+
+    const down = (event: KeyboardEvent) => {
+      const suggestedTableName = suggestion.name
+
+      if (event.key === 'Enter') {
+        event.preventDefault()
+
+        if (event.metaKey || event.ctrlKey) {
+          window.open(getTableLinkHref(suggestedTableName))
+        } else {
+          goToERD(suggestedTableName)
+        }
+      }
+    }
+
+    document.addEventListener('keydown', down)
+    return () => document.removeEventListener('keydown', down)
+  }, [suggestion, goToERD])
+
+  // Select option by pressing [Enter] key (with/without ⌘ key)
+  useEffect(() => {
+    // It doesn't subscribe a keydown event listener if the suggestion type is not "column"
+    if (suggestion?.type !== 'column') return
+
+    const down = (event: KeyboardEvent) => {
+      const { tableName, columnName } = suggestion
+
+      if (event.key === 'Enter') {
+        event.preventDefault()
+
+        if (event.metaKey || event.ctrlKey) {
+          window.open(getTableColumnLinkHref(tableName, columnName))
+        } else {
+          goToERD(tableName, columnName)
+        }
+      }
+    }
+
+    document.addEventListener('keydown', down)
+    return () => document.removeEventListener('keydown', down)
+  }, [suggestion, goToERD])
+
+  const table = schema.current.tables[tableName]
+  const columnTypeMap = useMemo(
+    () => (table ? getColumnTypeMap(table) : {}),
+    [table],
+  )
+
+  if (!table) {
+    return null
+  }
+
+  return (
+    <Command.Group heading="Tables">
+      <Command.Item
+        value={getSuggestionText({ type: 'table', name: table.name })}
+      >
+        <a
+          className={styles.item}
+          href={getTableLinkHref(table.name)}
+          onClick={(event) => {
+            // Do not call preventDefault to allow the default link behavior when ⌘ key is pressed
+            if (event.ctrlKey || event.metaKey) {
+              return
+            }
+
+            event.preventDefault()
+            goToERD(table.name)
+          }}
+        >
+          <Table2 className={styles.itemIcon} />
+          <span className={styles.itemText}>{table.name}</span>
+        </a>
+      </Command.Item>
+      {Object.values(table.columns).map((column) => (
+        <Command.Item
+          key={column.name}
+          value={getSuggestionText({
+            type: 'column',
+            tableName: table.name,
+            columnName: column.name,
+          })}
+        >
+          <a
+            className={clsx(styles.item, styles.indent)}
+            href={getTableColumnLinkHref(table.name, column.name)}
+            onClick={(event) => {
+              // Do not call preventDefault to allow the default link behavior when ⌘ key is pressed
+              if (event.ctrlKey || event.metaKey) {
+                return
+              }
+
+              event.preventDefault()
+              goToERD(table.name, column.name)
+            }}
+          >
+            {columnTypeMap[column.name] && (
+              <ColumnIcon
+                // biome-ignore lint/style/noNonNullAssertion: it checks the column type exists above
+                columnType={columnTypeMap[column.name]!}
+                className={styles.itemIcon}
+              />
+            )}
+            <span className={styles.itemText}>{column.name}</span>
+          </a>
+        </Command.Item>
+      ))}
+    </Command.Group>
+  )
+}
diff --git a/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteOptions/utils/getColumnTypeMap.ts b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteOptions/utils/getColumnTypeMap.ts
new file mode 100644
index 0000000000..7c18506a5f
--- /dev/null
+++ b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/CommandPaletteOptions/utils/getColumnTypeMap.ts
@@ -0,0 +1,29 @@
+import { isPrimaryKey, type Table } from '@liam-hq/schema'
+
+export type ColumnType = 'PRIMARY_KEY' | 'FOREIGN_KEY' | 'NOT_NULL' | 'NULLABLE'
+
+const isForeignKey = (columnName: string, table: Table): boolean => {
+  for (const constraint of Object.values(table.constraints)) {
+    if (constraint.type !== 'FOREIGN KEY') continue
+
+    if (constraint.columnNames.includes(columnName)) return true
+  }
+
+  return false
+}
+
+export const getColumnTypeMap = (table: Table) => {
+  const result: Record<string, ColumnType> = {}
+
+  Object.values(table.columns).forEach((column) => {
+    result[column.name] = isPrimaryKey(column.name, table.constraints)
+      ? 'PRIMARY_KEY'
+      : isForeignKey(column.name, table)
+        ? 'FOREIGN_KEY'
+        : column.notNull
+          ? 'NOT_NULL'
+          : 'NULLABLE'
+  })
+
+  return result
+}
diff --git a/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/types.ts b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/types.ts
index 430f87f135..1f3cd8a87e 100644
--- a/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/types.ts
+++ b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/types.ts
@@ -6,3 +6,4 @@ export type CommandPaletteInputMode =
 export type CommandPaletteSuggestion =
   | { type: 'table'; name: string }
   | { type: 'command'; name: string }
+  | { type: 'column'; tableName: string; columnName: string }
diff --git a/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/utils/suggestion.test.ts b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/utils/suggestion.test.ts
index 0c985c45dc..44c76a5f9a 100644
--- a/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/utils/suggestion.test.ts
+++ b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/utils/suggestion.test.ts
@@ -24,6 +24,18 @@ describe('getSuggestionText', () => {
 
     expect(result).toBe('command|show tables')
   })
+
+  it('should return "column|users|id" when suggestion is "id" column in "users" table', () => {
+    const suggestion: CommandPaletteSuggestion = {
+      type: 'column',
+      tableName: 'users',
+      columnName: 'id',
+    }
+
+    const result = getSuggestionText(suggestion)
+
+    expect(result).toBe('column|users|id')
+  })
 })
 
 describe('textToSuggestion', () => {
@@ -43,6 +55,18 @@ describe('textToSuggestion', () => {
     expect(result).toEqual({ type: 'command', name: 'hide tables' })
   })
 
+  it('should return the "id" column in "users" table suggestion when suggestion text is "column|posts|created_at"', () => {
+    const suggestionText = 'column|posts|created_at'
+
+    const result = textToSuggestion(suggestionText)
+
+    expect(result).toEqual({
+      type: 'column',
+      tableName: 'posts',
+      columnName: 'created_at',
+    })
+  })
+
   describe('with unexpected formats', () => {
     it('should return null when an unknown suggested type is given', () => {
       const suggestionText = 'fruits|lemon'
@@ -59,6 +83,14 @@ describe('textToSuggestion', () => {
 
       expect(result).toBeNull()
     })
+
+    it('should return null when a column name is empty', () => {
+      const suggestionText = 'column|users|'
+
+      const result = textToSuggestion(suggestionText)
+
+      expect(result).toBeNull()
+    })
   })
 })
 
@@ -67,6 +99,7 @@ describe('integration test, (value) => textToSuggestion(getSuggestionText(value)
     it.each<CommandPaletteSuggestion>([
       { type: 'table', name: 'user_posts' },
       { type: 'command', name: 'export as CSV' },
+      { type: 'column', tableName: 'users', columnName: 'email' },
     ])('in case: %p', (suggestion) => {
       const result = textToSuggestion(getSuggestionText(suggestion))
 
diff --git a/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/utils/suggestion.ts b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/utils/suggestion.ts
index 2c6f736387..c95d12b837 100644
--- a/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/utils/suggestion.ts
+++ b/frontend/packages/erd-core/src/features/erd/components/ERDRenderer/CommandPalette/utils/suggestion.ts
@@ -2,19 +2,31 @@ import type { CommandPaletteSuggestion } from '../types'
 
 const SEPARATOR = '|'
 
-export const getSuggestionText = (suggestion: CommandPaletteSuggestion) =>
-  `${suggestion.type}${SEPARATOR}${suggestion.name}`
+export const getSuggestionText = (suggestion: CommandPaletteSuggestion) => {
+  if (suggestion.type === 'column') {
+    return `${suggestion.type}${SEPARATOR}${suggestion.tableName}${SEPARATOR}${suggestion.columnName}`
+  }
+
+  return `${suggestion.type}${SEPARATOR}${suggestion.name}`
+}
 
 export const textToSuggestion = (
   text: string,
 ): CommandPaletteSuggestion | null => {
   const words = text.split(SEPARATOR)
 
-  const [suggestionType, name] = words
-  if (!suggestionType || !name) return null
+  const [suggestionType, name1, name2] = words
+  if (!suggestionType) return null
+
+  if (suggestionType === 'table' || suggestionType === 'command') {
+    if (!name1) return null
+    return { type: suggestionType, name: name1 }
+  }
 
-  if (suggestionType === 'table' || suggestionType === 'command')
-    return { type: suggestionType, name }
+  if (suggestionType === 'column') {
+    if (!name1 || !name2) return null
+    return { type: 'column', tableName: name1, columnName: name2 }
+  }
 
   return null
 }
diff --git a/frontend/packages/erd-core/src/features/erd/utils/url/getTableColumnLinkHref.test.ts b/frontend/packages/erd-core/src/features/erd/utils/url/getTableColumnLinkHref.test.ts
new file mode 100644
index 0000000000..2d8146bd81
--- /dev/null
+++ b/frontend/packages/erd-core/src/features/erd/utils/url/getTableColumnLinkHref.test.ts
@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest'
+import { getTableColumnLinkHref } from './getTableColumnLinkHref'
+
+it('should return the "active" query parameter and hash consistent with the table and column names', () => {
+  window.location.search = ''
+  window.location.hash = ''
+
+  expect(getTableColumnLinkHref('users', 'created_at')).toBe(
+    '?active=users#users__columns__created_at',
+  )
+})
+
+describe('when other query parameters and hash are present', () => {
+  it('should preserve existing query parameters and hash', () => {
+    window.location.search = '?page=2&sort=asc'
+    window.location.hash = '#other_hash'
+
+    expect(getTableColumnLinkHref('users', 'created_at')).toBe(
+      '?page=2&sort=asc&active=users#users__columns__created_at',
+    )
+  })
+})
diff --git a/frontend/packages/erd-core/src/features/erd/utils/url/getTableColumnLinkHref.ts b/frontend/packages/erd-core/src/features/erd/utils/url/getTableColumnLinkHref.ts
new file mode 100644
index 0000000000..be1e6deca9
--- /dev/null
+++ b/frontend/packages/erd-core/src/features/erd/utils/url/getTableColumnLinkHref.ts
@@ -0,0 +1,12 @@
+import type { QueryParam } from '../../../../schemas'
+import { getTableColumnElementId } from './getTableColumnElementId'
+
+export const getTableColumnLinkHref = (
+  activeTableName: string,
+  columnName: string,
+) => {
+  const searchParams = new URLSearchParams(window.location.search)
+  searchParams.set('active' satisfies QueryParam, activeTableName)
+  const targetElementId = getTableColumnElementId(activeTableName, columnName)
+  return `?${searchParams.toString()}#${targetElementId}`
+}
diff --git a/frontend/packages/erd-core/src/features/erd/utils/url/index.ts b/frontend/packages/erd-core/src/features/erd/utils/url/index.ts
index 115b7b1924..8a2a6905c8 100644
--- a/frontend/packages/erd-core/src/features/erd/utils/url/index.ts
+++ b/frontend/packages/erd-core/src/features/erd/utils/url/index.ts
@@ -1,2 +1,3 @@
 export * from './getTableColumnElementId'
+export * from './getTableColumnLinkHref'
 export * from './getTableLinkHref'