diff --git a/cypress/e2e/tables-be-filtering-types.cy.js b/cypress/e2e/tables-be-filtering-types.cy.js
new file mode 100644
index 0000000000..3bc1fcf0d3
--- /dev/null
+++ b/cypress/e2e/tables-be-filtering-types.cy.js
@@ -0,0 +1,406 @@
+/**
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+let localUser
+
+const today = new Date()
+const tomorrow = new Date(today)
+tomorrow.setUTCDate(tomorrow.getUTCDate() + 1)
+
+const formatDate = (date) => date.toISOString().split('T')[0]
+
+describe('Backend filtering in table header menu', () => {
+
+	before(function() {
+		cy.createRandomUser().then(user => {
+			localUser = user
+			cy.login(localUser)
+		})
+	})
+
+	beforeEach(function() {
+		cy.login(localUser)
+		cy.visit('apps/tables')
+	})
+
+	const openCreateRow = () => {
+		cy.get('[data-cy="createRowBtn"]').click()
+	}
+
+	const saveCreateRow = () => {
+		cy.get('[data-cy="createRowSaveButton"]').click()
+	}
+
+	const expectVisibleRows = (rows) => {
+		rows.forEach(row => {
+			cy.contains('[data-cy="ncTable"] [data-cy="customTableRow"]', row).should('be.visible')
+		})
+	}
+
+	const expectHiddenRows = (rows) => {
+		rows.forEach(row => {
+			cy.contains('[data-cy="ncTable"] [data-cy="customTableRow"]', row).should('not.exist')
+		})
+	}
+
+	const captureBackendFilterRequest = () => {
+		cy.intercept('GET', '**/apps/tables/row/table/*', req => {
+			if (req.query?.customFilters) {
+				req.alias = 'filterRequest'
+			}
+		})
+	}
+
+	const waitForBackendFilterRequest = () => {
+		cy.wait('@filterRequest').then(({ request }) => {
+			expect(request.query).to.have.property('customFilters')
+		})
+	}
+
+	const openColumnMenu = (columnTitle) => {
+		cy.contains('th', columnTitle).trigger('mouseover')
+		cy.contains('th', columnTitle)
+			.find('button[aria-label="Actions"], .action-item__menutoggle')
+			.first()
+			.click({ force: true })
+		getActivePopper()
+	}
+
+	const getActivePopper = () => cy.get('.v-popper__popper:visible').last()
+
+	const selectOperator = (operatorLabel) => {
+		cy.contains('button', 'Select Operator').click({ force: true })
+		getActivePopper().contains(operatorLabel).click({ force: true })
+	}
+
+	const submitTypedValue = (value) => {
+		getActivePopper().find('.action-input .input-field__input').first().clear().type(value)
+		getActivePopper().find('.action-input .input-field__trailing-button').first().click({ force: true })
+	}
+
+	const submitSelectionValue = (value) => {
+		getActivePopper().find('li.action .action-input__multi .vs__open-indicator-button').first().click({ force: true })
+		cy.get(`.v-popper__popper:visible ul.vs__dropdown-menu li span[title="${value}"]`).click({ force: true })
+		getActivePopper().contains('button', 'Submit').click({ force: true })
+		// close the floating menu to avoid capturing clicks in next interactions
+		cy.get('body').click(0, 0)
+	}
+
+	const submitMagicValue = (value) => {
+		getActivePopper().contains('button', value).click({ force: true })
+	}
+
+	const clickBackIfExists = () => {
+		cy.get('body').then($body => {
+			const backButton = $body
+				.find('.v-popper__popper:visible button')
+				.filter((_, el) => el.textContent?.trim() === 'Back')
+				.first()
+
+			if (backButton.length) {
+				cy.wrap(backButton).click({ force: true })
+			}
+		})
+	}
+
+	const applyHeaderFilter = (columnTitle, operatorLabel, value = null, valueMode = 'none') => {
+		captureBackendFilterRequest()
+		openColumnMenu(columnTitle)
+		// click Back if previous interaction left menu in previous used state
+		clickBackIfExists()
+		selectOperator(operatorLabel)
+
+		if (valueMode === 'typed') {
+			submitTypedValue(value)
+		}
+
+		if (valueMode === 'selection') {
+			submitSelectionValue(value)
+		}
+
+		if (valueMode === 'magic') {
+			submitMagicValue(value)
+		}
+		// close the floating menu to avoid capturing clicks in next interactions
+		cy.get('body').click(0, 0)
+		waitForBackendFilterRequest()
+	}
+
+	const addSingleFilterWithMagicValue = (columnLabel, operatorLabel, magicValueLabel) => {
+		applyHeaderFilter(columnLabel, operatorLabel, magicValueLabel, 'magic')
+	}
+
+	it('Filter by text line column (contains)', () => {
+		cy.createTable('Filter Types Header - Text Line')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createTextLineColumn('TextLine', null, null, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Match')
+		cy.fillInValueTextLine('TextLine', 'match-me')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Other')
+		cy.fillInValueTextLine('TextLine', 'other')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Empty')
+		saveCreateRow()
+
+		applyHeaderFilter('TextLine', 'Contains', 'match', 'typed')
+		expectVisibleRows(['Row Match'])
+		expectHiddenRows(['Row Other', 'Row Empty'])
+	})
+
+	it('Filter by text link column (contains)', () => {
+		cy.createTable('Filter Types Header - Text Link')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createTextLinkColumn('Link', ['Url'], false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row A')
+		cy.get('[data-cy="createRowModal"] [data-cy="Link"] .slot input').clear().type('https://a.example')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row B')
+		cy.get('[data-cy="createRowModal"] [data-cy="Link"] .slot input').clear().type('https://b.example')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Empty')
+		saveCreateRow()
+
+		applyHeaderFilter('Link', 'Contains', 'a.example', 'typed')
+		expectVisibleRows(['Row A'])
+		expectHiddenRows(['Row B', 'Row Empty'])
+	})
+
+	it('Filter by selection column (is equal)', () => {
+		cy.createTable('Filter Types Header - Selection')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createSelectionColumn('Selection', ['A', 'B', 'C'], null, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row A')
+		cy.fillInValueSelection('Selection', 'A')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row B')
+		cy.fillInValueSelection('Selection', 'B')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Empty')
+		saveCreateRow()
+
+		applyHeaderFilter('Selection', 'Is equal', 'B', 'selection')
+		expectVisibleRows(['Row B'])
+		expectHiddenRows(['Row A', 'Row Empty'])
+	})
+
+	it('Filter by selection multi column (contains)', () => {
+		cy.createTable('Filter Types Header - Selection Multi')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createSelectionMultiColumn('SelectionMulti', ['A', 'B', 'C'], null, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row B')
+		cy.fillInValueSelectionMulti('SelectionMulti', ['B'])
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row AC')
+		cy.fillInValueSelectionMulti('SelectionMulti', ['A', 'C'])
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Empty')
+		saveCreateRow()
+
+		applyHeaderFilter('SelectionMulti', 'Contains', 'B', 'selection')
+		expectVisibleRows(['Row B'])
+		expectHiddenRows(['Row AC', 'Row Empty'])
+	})
+
+	it('Selection multi: contains vs is equal behave differently', () => {
+		cy.createTable('Filter Types Header - Selection Multi Operators')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createSelectionMultiColumn('SelectionMulti', ['A', 'B', 'C'], null, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Only B')
+		cy.fillInValueSelectionMulti('SelectionMulti', ['B'])
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row A and B')
+		cy.fillInValueSelectionMulti('SelectionMulti', ['A', 'B'])
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Only A')
+		cy.fillInValueSelectionMulti('SelectionMulti', ['A'])
+		saveCreateRow()
+
+		// Contains uses contains-item logic and should match any row that includes B
+		applyHeaderFilter('SelectionMulti', 'Contains', 'B', 'selection')
+		expectVisibleRows(['Row Only B', 'Row A and B'])
+		expectHiddenRows(['Row Only A'])
+
+		//click Reset local adjustments
+		cy.contains('button', 'Reset local adjustments').click({ force: true })
+		cy.get('body').click(0, 0) // close menu
+
+		// Re-open the same operator menu and add an is-equal rule.
+		// For selection-multi, Is equal compares full rendered string,
+		// so only the exact single-value row should match "B".
+		applyHeaderFilter('SelectionMulti', 'Is equal', 'B', 'selection')
+		expectVisibleRows(['Row Only B'])
+		expectHiddenRows(['Row A and B', 'Row Only A'])
+	})
+
+	it('Filter by selection check column (checked)', () => {
+		cy.createTable('Filter Types Header - Selection Check')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createSelectionCheckColumn('Check', null, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Checked')
+		cy.fillInValueSelectionCheck('Check')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Unchecked')
+		saveCreateRow()
+
+		addSingleFilterWithMagicValue('Check', 'Is equal', 'Checked')
+		expectVisibleRows(['Row Checked'])
+		expectHiddenRows(['Row Unchecked'])
+	})
+
+	it('Filter by number column (is empty)', () => {
+		cy.createTable('Filter Types Header - Number')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createNumberColumn('Number', null, null, null, null, null, null, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 10')
+		cy.get('[data-cy="createRowModal"] [data-cy="Number"] input[type="number"]').clear().type('10')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Empty')
+		saveCreateRow()
+
+		applyHeaderFilter('Number', 'Is empty')
+		expectVisibleRows(['Row Empty'])
+		expectHiddenRows(['Row 10'])
+	})
+
+	it('Filter by progress column (is empty)', () => {
+		cy.createTable('Filter Types Header - Progress')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createNumberProgressColumn('Progress', null, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 90')
+		cy.get('[data-cy="createRowModal"] [data-cy="Progress"] input[type="number"]').clear().type('90')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Empty')
+		saveCreateRow()
+
+		applyHeaderFilter('Progress', 'Is empty')
+		expectVisibleRows(['Row Empty'])
+		expectHiddenRows(['Row 90'])
+	})
+
+	//we do not have empty option
+	it.skip('Filter by stars column (is empty)', () => {
+		cy.createTable('Filter Types Header - Stars')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createNumberStarsColumn('Stars', null, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 3')
+		for (let i = 0; i < 3; i++) {
+			cy.get('[data-cy="createRowModal"] [aria-label="Increase stars"]').click()
+		}
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Empty')
+		saveCreateRow()
+
+		applyHeaderFilter('Stars', 'Is empty')
+		expectVisibleRows(['Row Empty'])
+		expectHiddenRows(['Row 3'])
+	})
+
+	it('Filter by date column (is equal)', () => {
+		cy.createTable('Filter Types Header - Date')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createDatetimeDateColumn('Date', false, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Today')
+		cy.get('[data-cy="createRowModal"] [data-cy="Date"] input.native-datetime-picker--input').clear().type(formatDate(today))
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Tomorrow')
+		cy.get('[data-cy="createRowModal"] [data-cy="Date"] input.native-datetime-picker--input').clear().type(formatDate(tomorrow))
+		saveCreateRow()
+
+		applyHeaderFilter('Date', 'Is equal', formatDate(today), 'typed')
+		expectVisibleRows(['Row Today'])
+		expectHiddenRows(['Row Tomorrow'])
+	})
+
+	it('Filter by time column (is equal)', () => {
+		cy.createTable('Filter Types Header - Time')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createDatetimeTimeColumn('Time', false, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 08')
+		cy.get('[data-cy="createRowModal"] [data-cy="Time"] input.native-datetime-picker--input').clear().type('08:00')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 12')
+		cy.get('[data-cy="createRowModal"] [data-cy="Time"] input.native-datetime-picker--input').clear().type('12:00')
+		saveCreateRow()
+
+		applyHeaderFilter('Time', 'Is equal', '08:00', 'typed')
+		expectVisibleRows(['Row 08'])
+		expectHiddenRows(['Row 12'])
+	})
+
+	it('Filter by datetime column (is equal)', () => {
+		cy.createTable('Filter Types Header - DateTime')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createDatetimeColumn('DateTime', false, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row DT10')
+		cy.get('[data-cy="createRowModal"] [data-cy="DateTime"] input.native-datetime-picker--input').clear().type('2026-01-01T10:00')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row DT12')
+		cy.get('[data-cy="createRowModal"] [data-cy="DateTime"] input.native-datetime-picker--input').clear().type('2026-01-01T12:00')
+		saveCreateRow()
+
+		applyHeaderFilter('DateTime', 'Is equal', '2026-01-01 10:00', 'typed')
+		expectVisibleRows(['Row DT10'])
+		expectHiddenRows(['Row DT12'])
+	})
+
+})
diff --git a/cypress/e2e/tables-be-sorting-types.cy.js b/cypress/e2e/tables-be-sorting-types.cy.js
new file mode 100644
index 0000000000..ca42bf9db9
--- /dev/null
+++ b/cypress/e2e/tables-be-sorting-types.cy.js
@@ -0,0 +1,290 @@
+/**
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+let localUser
+
+describe('Backend sorting different types in table and view', () => {
+
+	before(function() {
+		cy.createRandomUser().then(user => {
+			localUser = user
+			cy.login(localUser)
+		})
+	})
+
+	beforeEach(function() {
+		cy.login(localUser)
+		cy.visit('apps/tables')
+	})
+
+	const openCreateRow = () => {
+		cy.get('[data-cy="createRowBtn"]').click()
+	}
+
+	const saveCreateRow = () => {
+		cy.get('[data-cy="createRowSaveButton"]').click()
+	}
+
+	const sortAndWait = (columnTitle, mode = 'ASC') => {
+		cy.intercept('GET', '**/apps/tables/row/table/*').as('sortingRequest')
+		cy.sortTableColumn(columnTitle, mode)
+		cy.wait('@sortingRequest').then(({ request }) => {
+			expect(request.query).to.have.property('sort')
+		})
+	}
+
+	const expectRowOrderByTitles = (expectedTitles) => {
+		cy.get('.custom-table table tbody tr').should('have.length', expectedTitles.length)
+		cy.get('.custom-table table tbody tr').then($rows => {
+			expectedTitles.forEach((title, index) => {
+				expect($rows.eq(index).text()).to.contain(title)
+			})
+		})
+	}
+
+	it('Sort by text line column', () => {
+		cy.createTable('Sort Types - Text Line')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createTextLineColumn('TextLine', null, null, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 1')
+		cy.fillInValueTextLine('TextLine', 'Charlie')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 2')
+		cy.fillInValueTextLine('TextLine', 'Alice')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 3')
+		cy.fillInValueTextLine('TextLine', 'Bob')
+		saveCreateRow()
+
+		sortAndWait('TextLine', 'ASC')
+		expectRowOrderByTitles(['Row 2', 'Row 3', 'Row 1'])
+	})
+
+	it('Sort by text link column', () => {
+		cy.createTable('Sort Types - Text Link')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createTextLinkColumn('Link', ['Url'], false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row Z')
+		cy.get('[data-cy="createRowModal"] [data-cy="Link"] .slot input').clear().type('https://z.example')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row A')
+		cy.get('[data-cy="createRowModal"] [data-cy="Link"] .slot input').clear().type('https://a.example')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row B')
+		cy.get('[data-cy="createRowModal"] [data-cy="Link"] .slot input').clear().type('https://b.example')
+		saveCreateRow()
+
+		sortAndWait('Link', 'ASC')
+		expectRowOrderByTitles(['Row A', 'Row B', 'Row Z'])
+	})
+
+	it('Sort by selection column', () => {
+		cy.createTable('Sort Types - Selection')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createSelectionColumn('Selection', ['A', 'B', 'C'], null, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row C')
+		cy.fillInValueSelection('Selection', 'C')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row A')
+		cy.fillInValueSelection('Selection', 'A')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row B')
+		cy.fillInValueSelection('Selection', 'B')
+		saveCreateRow()
+
+		sortAndWait('Selection', 'ASC')
+		expectRowOrderByTitles(['Row A', 'Row B', 'Row C'])
+	})
+
+	it('Sort by multi selection column', () => {
+		cy.createTable('Sort Types - Selection Multi')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createSelectionMultiColumn('SelectionMulti', ['A', 'B', 'C'], null, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row C')
+		cy.fillInValueSelectionMulti('SelectionMulti', ['C'])
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row A')
+		cy.fillInValueSelectionMulti('SelectionMulti', ['A'])
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row B')
+		cy.fillInValueSelectionMulti('SelectionMulti', ['B'])
+		saveCreateRow()
+
+		sortAndWait('SelectionMulti', 'ASC')
+		expectRowOrderByTitles(['Row A', 'Row B', 'Row C'])
+	})
+
+	it('Sort by number column', () => {
+		cy.createTable('Sort Types - Number')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createNumberColumn('Number', null, null, null, null, null, null, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 30')
+		cy.get('[data-cy="createRowModal"] [data-cy="Number"] input[type="number"]').clear().type('30')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 10')
+		cy.get('[data-cy="createRowModal"] [data-cy="Number"] input[type="number"]').clear().type('10')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 20')
+		cy.get('[data-cy="createRowModal"] [data-cy="Number"] input[type="number"]').clear().type('20')
+		saveCreateRow()
+
+		sortAndWait('Number', 'ASC')
+		expectRowOrderByTitles(['Row 10', 'Row 20', 'Row 30'])
+	})
+
+	it('Sort by progress column', () => {
+		cy.createTable('Sort Types - Progress')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createNumberProgressColumn('Progress', null, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 90')
+		cy.get('[data-cy="createRowModal"] [data-cy="Progress"] input[type="number"]').clear().type('90')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 10')
+		cy.get('[data-cy="createRowModal"] [data-cy="Progress"] input[type="number"]').clear().type('10')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 50')
+		cy.get('[data-cy="createRowModal"] [data-cy="Progress"] input[type="number"]').clear().type('50')
+		saveCreateRow()
+
+		sortAndWait('Progress', 'ASC')
+		expectRowOrderByTitles(['Row 10', 'Row 50', 'Row 90'])
+	})
+
+	it('Sort by stars column', () => {
+		cy.createTable('Sort Types - Stars')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createNumberStarsColumn('Stars', null, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 5')
+		for (let i = 0; i < 5; i++) {
+			cy.get('[data-cy="createRowModal"] [aria-label="Increase stars"]').click()
+		}
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 1')
+		cy.get('[data-cy="createRowModal"] [aria-label="Increase stars"]').click()
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row 3')
+		for (let i = 0; i < 3; i++) {
+			cy.get('[data-cy="createRowModal"] [aria-label="Increase stars"]').click()
+		}
+		saveCreateRow()
+
+		sortAndWait('Stars', 'ASC')
+		expectRowOrderByTitles(['Row 1', 'Row 3', 'Row 5'])
+	})
+
+	it('Sort by date column', () => {
+		cy.createTable('Sort Types - Date')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createDatetimeDateColumn('Date', false, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row D3')
+		cy.get('[data-cy="createRowModal"] [data-cy="Date"] input.native-datetime-picker--input').clear().type('2026-01-03')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row D1')
+		cy.get('[data-cy="createRowModal"] [data-cy="Date"] input.native-datetime-picker--input').clear().type('2026-01-01')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row D2')
+		cy.get('[data-cy="createRowModal"] [data-cy="Date"] input.native-datetime-picker--input').clear().type('2026-01-02')
+		saveCreateRow()
+
+		sortAndWait('Date', 'ASC')
+		expectRowOrderByTitles(['Row D1', 'Row D2', 'Row D3'])
+	})
+
+	it('Sort by time column', () => {
+		cy.createTable('Sort Types - Time')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createDatetimeTimeColumn('Time', false, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row T23')
+		cy.get('[data-cy="createRowModal"] [data-cy="Time"] input.native-datetime-picker--input').clear().type('23:30')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row T08')
+		cy.get('[data-cy="createRowModal"] [data-cy="Time"] input.native-datetime-picker--input').clear().type('08:15')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row T12')
+		cy.get('[data-cy="createRowModal"] [data-cy="Time"] input.native-datetime-picker--input').clear().type('12:00')
+		saveCreateRow()
+
+		sortAndWait('Time', 'ASC')
+		expectRowOrderByTitles(['Row T08', 'Row T12', 'Row T23'])
+	})
+
+	it('Sort by datetime column', () => {
+		cy.createTable('Sort Types - DateTime')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createDatetimeColumn('DateTime', false, false)
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row DT12')
+		cy.get('[data-cy="createRowModal"] [data-cy="DateTime"] input.native-datetime-picker--input').clear().type('2026-01-01T12:00')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row DT08')
+		cy.get('[data-cy="createRowModal"] [data-cy="DateTime"] input.native-datetime-picker--input').clear().type('2026-01-01T08:00')
+		saveCreateRow()
+
+		openCreateRow()
+		cy.fillInValueTextLine('Name', 'Row DT10')
+		cy.get('[data-cy="createRowModal"] [data-cy="DateTime"] input.native-datetime-picker--input').clear().type('2026-01-01T10:00')
+		saveCreateRow()
+
+		sortAndWait('DateTime', 'ASC')
+		expectRowOrderByTitles(['Row DT08', 'Row DT10', 'Row DT12'])
+	})
+
+})
diff --git a/cypress/e2e/tables-be-sorting.cy.js b/cypress/e2e/tables-be-sorting.cy.js
new file mode 100644
index 0000000000..5679b608a5
--- /dev/null
+++ b/cypress/e2e/tables-be-sorting.cy.js
@@ -0,0 +1,316 @@
+/**
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+let localUser
+
+describe('Backend sorting in table and view', () => {
+
+	before(function() {
+		cy.createRandomUser().then(user => {
+			localUser = user
+			cy.login(localUser)
+		})
+	})
+
+	beforeEach(function() {
+		cy.login(localUser)
+		cy.visit('apps/tables')
+	})
+
+	it('Table header sorting - single column ascending', () => {
+		cy.createTable('Sorting Table')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createNumberColumn('Score')
+
+		// Create test rows with unsorted data
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('Alice')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('Charlie')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('Bob')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		// Intercept backend sorting request
+		cy.intercept('GET', '**/apps/tables/row/table/*').as('sortingRequest')
+
+		// Sort by Name column ascending
+		cy.sortTableColumn('Name', 'ASC')
+
+		// Wait for backend request to complete
+		cy.wait('@sortingRequest')
+
+		// Verify sorting after backend confirms
+		cy.get('.custom-table table tbody tr').then($rows => {
+			expect($rows.eq(0).text()).to.contain('Alice')
+			expect($rows.eq(1).text()).to.contain('Bob')
+			expect($rows.eq(2).text()).to.contain('Charlie')
+		})
+	})
+
+	it('Table header sorting - single column descending', () => {
+		cy.createTable('Sorting Table Desc')
+		cy.createTextLineColumn('Name', null, null, true)
+
+		// Create test rows
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('Alice')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('Charlie')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('Bob')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		// Intercept backend sorting request
+		cy.intercept('GET', '**/apps/tables/row/table/*').as('sortingDescRequest')
+
+		// Sort by Name column descending
+		cy.sortTableColumn('Name', 'DESC')
+
+		// Wait for backend request to complete
+		cy.wait('@sortingDescRequest')
+
+		// Verify sorting after backend confirms
+		cy.get('.custom-table table tbody tr').then($rows => {
+			expect($rows.eq(0).text()).to.contain('Charlie')
+			expect($rows.eq(1).text()).to.contain('Bob')
+			expect($rows.eq(2).text()).to.contain('Alice')
+		})
+	})
+
+	it('Sort by number column - ascending order', () => {
+		cy.createTable('Number Sorting Table')
+		cy.createTextLineColumn('Name', null, null, true)
+		cy.createNumberColumn('Value')
+
+		// Create rows with numbers in random order
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('First')
+		cy.get('[data-cy="createRowModal"] input[type="number"]').first().clear().type('30')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('Second')
+		cy.get('[data-cy="createRowModal"] input[type="number"]').first().clear().type('10')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('Third')
+		cy.get('[data-cy="createRowModal"] input[type="number"]').first().clear().type('20')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		// Intercept backend sorting request
+		cy.intercept('GET', '**/apps/tables/row/table/*').as('sortingRequest')
+
+		// Sort by number column ascending
+		cy.sortTableColumn('Value', 'ASC')
+
+		// Wait for backend request to complete
+		cy.wait('@sortingRequest')
+
+		// Verify sorting by number is applied after backend confirms
+		cy.get('.custom-table table tbody tr').should('have.length', 3)
+		cy.get('.custom-table table tbody tr').then($rows => {
+			expect($rows.eq(0).text()).to.contain('Second')
+			expect($rows.eq(1).text()).to.contain('Third')
+			expect($rows.eq(2).text()).to.contain('First')
+		})
+	})
+
+	it('View preset sorting - verify saved sort persists', () => {
+		cy.createTable('View Sorting Table')
+		cy.createTextLineColumn('Title', null, null, true)
+		cy.createTextLineColumn('Category')
+
+		// Create test rows
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('Item A')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('Item Z')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		// Create a view and configure sorting
+		cy.createView('Sorted View')
+		cy.get('[data-cy="customTableAction"] button').click()
+		cy.get('.v-popper__popper li button span').contains('Edit view').click({ force: true })
+		cy.get('[data-cy="viewSettingsDialogTitleInput"]').should('be.visible')
+
+		// Open view settings and configure sort
+		cy.get('#settings-section_sort').should('exist')
+		cy.get('#settings-section_sort button').contains('Add new sorting rule').click({ force: true })
+		cy.get('#settings-section_sort .sort-entry').should('have.length.at.least', 1)
+		cy.get('#settings-section_sort .sort-entry .v-select .vs__open-indicator-button').first().click({ force: true })
+		cy.contains('.vs__dropdown-menu li', 'Title').click({ force: true })
+
+		// Verify sort direction can be set
+		cy.get('#settings-section_sort .sort-entry .mode-switch .checkbox-radio-switch__input[value="ASC"]').should('exist')
+
+		// Save view settings
+		cy.get('[data-cy="modifyViewBtn"]').click()
+
+		// Verify view is created with sorting
+		cy.get('[data-cy="navigationViewItem"]').contains('Sorted View').should('exist')
+	})
+
+	it.skip('Sorting persistence - table vs view', () => {
+		// Create first table
+		cy.createTable('First Table')
+		cy.createTextLineColumn('Data', null, null, true)
+
+		// Create second table and view
+		cy.createTable('Second Table')
+		cy.createTextLineColumn('Content', null, null, true)
+
+		// Load first table and apply sort
+		cy.loadTable('First Table')
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('A')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('B')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		// Intercept backend sorting request
+		cy.intercept('GET', '**/apps/tables/row/table/*').as('sortingRequest')
+
+		cy.sortTableColumn('Data', 'DESC')
+
+		// Wait for backend request to complete
+		cy.wait('@sortingRequest')
+
+		// Reset local adjustments is view-specific and should not be shown on tables
+		cy.contains('button', 'Reset local adjustments').should('not.exist')
+
+		// Navigate to second table - local sort should be reset
+		cy.loadTable('Second Table')
+		cy.get('.info').contains('Reset local adjustments').should('not.exist')
+
+		// Navigate back to first table - reset action should still not be visible on tables
+		cy.loadTable('First Table')
+		cy.contains('button', 'Reset local adjustments').should('not.exist')
+	})
+
+	it('Multiple sort rules in view settings', () => {
+		cy.createTable('Multi Sort Table')
+		cy.createTextLineColumn('Category', null, null, true)
+		cy.createTextLineColumn('Name', null, null, false)
+		cy.createNumberColumn('Priority')
+
+		// Create view
+		cy.createView('Multi Sort View')
+
+		// Navigate to view settings
+		cy.get('[data-cy="navigationViewItem"]').contains('Multi Sort View').click({ force: true })
+		cy.get('[data-cy="customTableAction"] button').click()
+		cy.get('.v-popper__popper li button span').contains('Edit view').click({ force: true })
+
+		// Configure primary sort
+		cy.get('#settings-section_sort button').contains('Add new sorting rule').click({ force: true })
+		cy.get('#settings-section_sort .sort-entry').should('have.length', 1)
+		cy.get('#settings-section_sort .sort-entry .v-select .vs__open-indicator-button').first().click({ force: true })
+		cy.contains('.vs__dropdown-menu li', 'Category').click({ force: true })
+		cy.get('#settings-section_sort .sort-entry .mode-switch .checkbox-radio-switch__input[value="DESC"]').check({ force: true })
+		cy.get('#settings-section_sort .sort-entry .mode-switch .checkbox-radio-switch__input[value="DESC"]').should('be.checked')
+
+		// Save settings
+		cy.get('[data-cy="modifyViewBtn"]').click()
+
+		// Verify view loads without errors
+		cy.get('[data-cy="ncTable"]').should('exist')
+	})
+
+	it('Sort with text search applied', () => {
+		cy.createTable('Search Sort Table')
+		cy.createTextLineColumn('Title', null, null, true)
+
+		// Create test rows
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('Apple')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('Banana')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('Apricot')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		// Apply search filter
+		cy.get('.searchAndFilter input').type('Ap')
+
+		// Intercept backend request that contains both filter and sort
+		//@todo apply it after seach will be moved to the backend
+		// cy.intercept('GET', '**/apps/tables/row/table/*', req => {
+		// 	if (req.query?.sort && req.query?.customFilters) {
+		// 		req.alias = 'filteredSortingRequest'
+		// 	}
+		// })
+
+		// Verify sorting applies to filtered results
+		cy.get('.custom-table table tbody tr').should('have.length.greaterThan', 0)
+
+		// Apply sort on filtered results
+		cy.sortTableColumn('Title', 'ASC')
+
+		//check the order
+		cy.get('.custom-table table tbody tr').first().should('contain', 'Apple')
+
+		//chnage the ordering
+		cy.sortTableColumn('Title', 'DESC')
+
+		//check the order for second tr scond is not a function
+		cy.get('.custom-table table tbody tr').first().should('contain', 'Apricot')
+
+		//check if not contains the non filtered item
+		cy.get('.custom-table table tbody tr').should('not.contain', 'Banana')
+		//@todo apply it after seach will be moved to the backend
+		// Wait for backend request to complete
+		// cy.wait('@filteredSortingRequest').then(({ request }) => {
+		// 	expect(request.query).to.have.property('sort')
+		// 	expect(request.query).to.have.property('customFilters')
+		// })
+	})
+
+	it('View navigation - sort settings not affected by table changes', () => {
+		cy.createTable('Table 1 Sort')
+		cy.createTextLineColumn('Col1', null, null, true)
+
+		cy.createView('View A')
+
+		// Add rows
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('Z')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+
+		cy.get('[data-cy="createRowBtn"]').click()
+		cy.get('[data-cy="createRowModal"] input').first().type('A')
+		cy.get('[data-cy="createRowSaveButton"]').click()
+		// Intercept backend sorting request
+		cy.intercept('GET', '**/apps/tables/row/view/*').as('sortingRequest')
+
+		// Apply local sort on view
+		cy.sortTableColumn('Col1', 'DESC')
+		// Wait for backend request to complete
+		cy.wait('@sortingRequest')
+
+		cy.get('.info').contains('Reset local adjustments').should('be.visible')
+
+		// Navigate to table
+		cy.loadTable('Table 1 Sort')
+		cy.get('.info').contains('Reset local adjustments').should('not.exist')
+	})
+
+})
diff --git a/lib/Controller/RowController.php b/lib/Controller/RowController.php
index caa0e7ee27..1a39462bf0 100644
--- a/lib/Controller/RowController.php
+++ b/lib/Controller/RowController.php
@@ -31,26 +31,30 @@ public function __construct(
 	/**
 	 * @param int $tableId ID of the table
 	 * @param string $customFilters JSON-encoded array of filter groups to apply
+	 * @param string $sort JSON-encoded array of sort rules to apply, an empty array disables default sorting
 	 */
 	#[NoAdminRequired]
 	#[RequirePermission(permission: Application::PERMISSION_READ, type: Application::NODE_TYPE_TABLE, idParam: 'tableId')]
-	public function index(int $tableId, string $customFilters = ''): DataResponse {
-		return $this->handleError(function () use ($tableId, $customFilters) {
+	public function index(int $tableId, string $customFilters = '', string $sort = ''): DataResponse {
+		return $this->handleError(function () use ($tableId, $customFilters, $sort) {
 			$customFilters = json_decode($customFilters, true) ?? [];
-			return $this->service->findAllByTable($tableId, $this->userId, customFilters: $customFilters);
+			$sort = $sort === '' ? null : (json_decode($sort, true) ?? []);
+			return $this->service->findAllByTable($tableId, $this->userId, customFilters: $customFilters, sort: $sort);
 		});
 	}
 
 	/**
 	 * @param int $viewId ID of the view
 	 * @param string $customFilters JSON-encoded array of filter groups to apply
+	 * @param string $sort JSON-encoded array of sort rules to apply, an empty array disables default sorting
 	 */
 	#[NoAdminRequired]
 	#[RequirePermission(permission: Application::PERMISSION_READ, type: Application::NODE_TYPE_VIEW, idParam: 'viewId')]
-	public function indexView(int $viewId, string $customFilters = ''): DataResponse {
-		return $this->handleError(function () use ($viewId, $customFilters) {
+	public function indexView(int $viewId, string $customFilters = '', string $sort = ''): DataResponse {
+		return $this->handleError(function () use ($viewId, $customFilters, $sort) {
 			$customFilters = json_decode($customFilters, true) ?? [];
-			return $this->service->findAllByView($viewId, $this->userId, customFilters: $customFilters);
+			$sort = $sort === '' ? null : (json_decode($sort, true) ?? []);
+			return $this->service->findAllByView($viewId, $this->userId, customFilters: $customFilters, sort: $sort);
 		});
 	}
 
diff --git a/lib/Db/Row2Mapper.php b/lib/Db/Row2Mapper.php
index 2dd49caaa5..54c564bcce 100644
--- a/lib/Db/Row2Mapper.php
+++ b/lib/Db/Row2Mapper.php
@@ -178,7 +178,7 @@ private function getWantedRowIds(string $userId, int $tableId, ?array $filter =
 	 */
 	public function findAll(array $showColumnIds, int $tableId, ?int $limit = null, ?int $offset = null, ?array $filter = null, ?array $sort = null, ?string $userId = null, array $customFilters = []): array {
 		try {
-			$this->columnMapper->preloadColumns($showColumnIds, $filter, $sort);
+			$this->columnMapper->preloadColumns($showColumnIds, $filter, $sort, $customFilters);
 
 			$wantedRowIdsArray = $this->getWantedRowIds($userId, $tableId, $filter, $sort, $limit, $offset, $customFilters);
 
diff --git a/lib/Service/RowService.php b/lib/Service/RowService.php
index 21f1ac5aae..c6e42de4a6 100644
--- a/lib/Service/RowService.php
+++ b/lib/Service/RowService.php
@@ -91,18 +91,21 @@ public function formatRowsForPublicShare(array $rows): array {
 	 * @param ?int $limit
 	 * @param ?int $offset
 	 * @param array $customFilters
+	 * @param array|null $sort JSON-decoded sort rules, null to use the table default, an empty array for no sorting
 	 * @return Row2[]
 	 * @throws InternalError
 	 * @throws PermissionError
 	 */
-	public function findAllByTable(int $tableId, string $userId, ?int $limit = null, ?int $offset = null, array $customFilters = []): array {
+	public function findAllByTable(int $tableId, string $userId, ?int $limit = null, ?int $offset = null, array $customFilters = [], ?array $sort = null): array {
 		try {
 			if ($this->permissionsService->canReadRowsByElementId($tableId, 'table', $userId)) {
 				$tableColumns = $this->columnMapper->findAllByTable($tableId);
 				$showColumnIds = array_map(fn (Column $column) => $column->getId(), $tableColumns);
 
-				$table = $this->tableMapper->find($tableId);
-				$sort = $table->getSortArray() ?: null;
+				if ($sort === null) {
+					$table = $this->tableMapper->find($tableId);
+					$sort = $table->getSortArray() ?: null;
+				}
 
 				$rows = $this->row2Mapper->findAll($showColumnIds, $tableId, $limit, $offset, null, $sort, $userId, $customFilters);
 				$this->attachAliasPayloads($rows, $tableColumns);
@@ -122,24 +125,29 @@ public function findAllByTable(int $tableId, string $userId, ?int $limit = null,
 	 * @param int|null $limit
 	 * @param int|null $offset
 	 * @param array $customFilters
+	 * @param array|null $sort JSON-decoded sort rules, null to use the view default, an empty array for no sorting
 	 * @return Row2[]
 	 * @throws DoesNotExistException
 	 * @throws InternalError
 	 * @throws MultipleObjectsReturnedException
 	 * @throws PermissionError
 	 */
-	public function findAllByView(int $viewId, string $userId, ?int $limit = null, ?int $offset = null, array $customFilters = []): array {
+	public function findAllByView(int $viewId, string $userId, ?int $limit = null, ?int $offset = null, array $customFilters = [], ?array $sort = null): array {
 		try {
 			if ($this->permissionsService->canReadRowsByElementId($viewId, 'view', $userId)) {
 				$view = $this->viewMapper->find($viewId);
 
+				if ($sort === null) {
+					$sort = $view->getSortArray();
+				}
+
 				$rows = $this->row2Mapper->findAll(
 					$view->getColumnIds(),
 					$view->getTableId(),
 					$limit,
 					$offset,
 					$view->getFilterArray(),
-					$view->getSortArray(),
+					$sort,
 					$this->resolveFilterUserId($userId, $view),
 					$customFilters,
 				);
diff --git a/src/modules/main/partials/editTablePartials/DefaultSortRules.vue b/src/modules/main/partials/editTablePartials/DefaultSortRules.vue
index 2e21447fd3..40673188ff 100644
--- a/src/modules/main/partials/editTablePartials/DefaultSortRules.vue
+++ b/src/modules/main/partials/editTablePartials/DefaultSortRules.vue
@@ -31,7 +31,7 @@
 import SortEntry from '../editViewPartials/sort/SortEntry.vue'
 import { NcButton } from '@nextcloud/vue'
 import Plus from 'vue-material-design-icons/Plus.vue'
-import { ColumnTypes } from '../../../../shared/components/ncTable/mixins/columnHandler.js'
+import { isBackendSortableColumn } from '../../../../shared/components/ncTable/mixins/sortSupport.js'
 
 export default {
 	name: 'DefaultSortRules',
@@ -64,25 +64,8 @@ export default {
 		},
 	},
 	methods: {
-		/**
-		 * The method rejects column types for which there is no sort support on the backend.
-		 *
-		 * Important:
-		 * - Not all columns that are sortable on the front-end are sortable on the back-end.
-		 * - Example: "selection" fields — the front-end can sort them by value (since it has it),
-		 *   but the back-end only stores an ID and cannot easily JOIN the value for sorting.
-		 * @param {AbstractColumn} col The column to check.
-		 */
-		canBeSorted(col) {
-			return ![
-				ColumnTypes.Selection,
-				ColumnTypes.SelectionMulti,
-				ColumnTypes.TextLink,
-				ColumnTypes.Usergroup,
-			].includes(col.type)
-		},
 		eligibleColumns(selectedId) {
-			return this.columns?.filter(col => col.canSort() && this.canBeSorted(col) && (!this.mutableSort.map(e => e.columnId).includes(col.id) || col.id === selectedId))
+			return this.columns?.filter(col => isBackendSortableColumn(col) && (!this.mutableSort.map(e => e.columnId).includes(col.id) || col.id === selectedId))
 		},
 		deleteSortingRule(index) {
 			this.mutableSort.splice(index, 1)
diff --git a/src/modules/main/partials/editViewPartials/sort/SortForm.vue b/src/modules/main/partials/editViewPartials/sort/SortForm.vue
index 52cb907c32..b99f46824c 100644
--- a/src/modules/main/partials/editViewPartials/sort/SortForm.vue
+++ b/src/modules/main/partials/editViewPartials/sort/SortForm.vue
@@ -55,7 +55,7 @@ import DeletedSortEntry from './DeletedSortEntry.vue'
 import SortEntry from './SortEntry.vue'
 import { NcButton } from '@nextcloud/vue'
 import Plus from 'vue-material-design-icons/Plus.vue'
-import { ColumnTypes } from '../../../../../shared/components/ncTable/mixins/columnHandler.js'
+import { isBackendSortableColumn } from '../../../../../shared/components/ncTable/mixins/sortSupport.js'
 
 export default {
 	name: 'SortForm',
@@ -120,26 +120,9 @@ export default {
 		isSameEntry(object, searchObject) {
 			return Object.keys(searchObject).every((key) => object[key] === searchObject[key])
 		},
-		/**
-		 * The method rejects column types for which there is no sort support on the backend.
-		 *
-		 * Important:
-		 * - Not all columns that are sortable on the front-end are sortable on the back-end.
-		 * - Example: "selection" fields — the front-end can sort them by value (since it has it),
-		 *   but the back-end only stores an ID and cannot easily JOIN the value for sorting.
-		 * @param {AbstractColumn} col The column to check.
-		 */
-		canBeSorted(col) {
-			return ![
-				ColumnTypes.Selection,
-				ColumnTypes.SelectionMulti,
-				ColumnTypes.TextLink,
-				ColumnTypes.Usergroup,
-			].includes(col.type)
-		},
 		eligibleColumns(selectedId) { // filter sortable and unused columns
-			if (this.hadHiddenSortingRules || !this.viewSort) return this.columns?.filter(col => col.canSort() && this.canBeSorted(col))
-			return this.columns.filter(col => col.canSort() && this.canBeSorted(col) && (!this.viewSort.map(entry => entry.columnId).includes(col.id) || col.id === selectedId))
+			if (this.hadHiddenSortingRules || !this.viewSort) return this.columns?.filter(col => isBackendSortableColumn(col))
+			return this.columns.filter(col => isBackendSortableColumn(col) && (!this.viewSort.map(entry => entry.columnId).includes(col.id) || col.id === selectedId))
 		},
 		deleteSortingRule(index) {
 			this.mutableSort.splice(index, 1)
diff --git a/src/modules/main/sections/MainWrapper.vue b/src/modules/main/sections/MainWrapper.vue
index 968cb3aa25..3d5a8b60ed 100644
--- a/src/modules/main/sections/MainWrapper.vue
+++ b/src/modules/main/sections/MainWrapper.vue
@@ -11,7 +11,7 @@
 				:view="element"
 				:columns="columns"
 				:rows="rows"
-				:view-setting="viewSetting"
+				:view-setting.sync="viewSetting"
 				@create-column="createColumn"
 				@import="openImportModal"
 				@download-csv="downloadCSV"
@@ -22,7 +22,7 @@
 				:table="element"
 				:columns="columns"
 				:rows="rows"
-				:view-setting="viewSetting"
+				:view-setting.sync="viewSetting"
 				@create-column="createColumn"
 				@import="openImportModal"
 				@download-csv="downloadCSV"
@@ -45,6 +45,9 @@ import { useTablesStore } from '../../../store/store.js'
 import { useDataStore } from '../../../store/data.js'
 import { computed } from 'vue'
 import { showError } from '@nextcloud/dialogs'
+import { translate as t } from '@nextcloud/l10n'
+import { buildBackendFilterQuery } from '../../../shared/components/ncTable/mixins/filterSupport.js'
+import { getExplicitSortRules, normalizeBackendSortRulesForColumns } from '../../../shared/components/ncTable/mixins/sortSupport.js'
 
 export default {
 	name: 'MainWrapper',
@@ -81,13 +84,14 @@ export default {
 			localLoading: false,
 			lastActiveElement: null,
 			viewSetting: {},
+			isRefreshing: false,
 		}
 	},
 
 	computed: {
 		...mapState(useTablesStore, ['activeRowId']),
-		customFiltered() {
-			return this.$route.query.customFilters
+		backendQueryKey() {
+			return JSON.stringify(this.buildRefreshQuery())
 		},
 	},
 
@@ -98,8 +102,12 @@ export default {
 		activeRowId() {
 			this.reload()
 		},
-		customFiltered() {
-			this.reload(true)
+		backendQueryKey() {
+			if (!this.element || this.localLoading || this.isRefreshing || !this.lastActiveElement) {
+				return
+			}
+
+			this.refreshRows()
 		},
 	},
 
@@ -155,25 +163,70 @@ export default {
 		deleteRows(rowIds) {
 			this.rowsToDelete = rowIds
 		},
-		async reload(force = false) {
+		buildRefreshQuery() {
+			const columns = this.columns || []
+			const effectiveSort = normalizeBackendSortRulesForColumns(getExplicitSortRules(this.viewSetting), columns)
+			const customFilters = buildBackendFilterQuery(this.$route.query.customFilters, this.viewSetting, columns)
+
+			return {
+				customFilters,
+				sort: effectiveSort.length > 0 ? JSON.stringify(effectiveSort) : null,
+			}
+		},
+		async refreshRows() {
+			this.isRefreshing = true
+			try {
+				await this.syncRows({ showRefreshError: true })
+			} finally {
+				this.isRefreshing = false
+			}
+		},
+		async syncRows({ showRefreshError = false } = {}) {
+			if (!this.canReadData(this.element)) {
+				await this.removeRows({
+					isView: this.isView,
+					elementId: this.element.id,
+				})
+				return
+			}
+
+			const refreshQuery = this.buildRefreshQuery()
+			const rowsLoaded = await this.loadRowsFromBE({
+				viewId: this.isView ? this.element.id : null,
+				tableId: this.isView ? null : this.element.id,
+				customFilters: refreshQuery.customFilters,
+				sort: refreshQuery.sort,
+			})
+
+			if (showRefreshError && rowsLoaded === false) {
+				showError(t('tables', 'Error refreshing, please try to reload the whole page'))
+			}
+		},
+		async reload(force = false, manualRefresh = false) {
 			if (!this.element) {
 				return
 			}
 
-			// Used to reload View from backend, in case there are Filter updates
-			const isLastElementSameAndView = this.element.id === this.lastActiveElement?.id && this.isView === this.lastActiveElement?.isView
+			const sameElement = this.lastActiveElement
+				&& this.element.id === this.lastActiveElement.id
+				&& this.isView === this.lastActiveElement.isView
 
-			if (!this.lastActiveElement || this.element.id !== this.lastActiveElement.id || isLastElementSameAndView || this.isView !== this.lastActiveElement.isView || force) {
-				this.localLoading = true
+			if (sameElement && !force) {
+				return
+			}
 
-				// Since we show one page at a time, no need keep other tables in the store
+			if (manualRefresh) {
+				this.isRefreshing = true
+			} else {
+				this.localLoading = true
 				this.clearState()
-
 				this.viewSetting = {}
 				if (this.element?.sort?.length) {
 					this.viewSetting.presetSorting = [...this.element.sort]
 				}
+			}
 
+			try {
 				await this.loadColumnsFromBE({
 					view: this.isView ? this.element : null,
 					tableId: !this.isView ? this.element.id : null,
@@ -185,18 +238,8 @@ export default {
 					force: true,
 				})
 
-				if (this.canReadData(this.element)) {
-					await this.loadRowsFromBE({
-						viewId: this.isView ? this.element.id : null,
-						tableId: !this.isView ? this.element.id : null,
-						customFilters: this.$route.query.customFilters,
-					})
-				} else {
-					await this.removeRows({
-						isView: this.isView,
-						elementId: this.element.id,
-					})
-				}
+				await this.syncRows({ showRefreshError: manualRefresh })
+
 				this.lastActiveElement = {
 					id: this.element.id,
 					isView: this.isView,
@@ -204,7 +247,9 @@ export default {
 				if (this.activeRowId) {
 					emit('tables:row:edit', { row: this.rows.find(r => r.id === this.activeRowId), columns: this.columns, isView: this.isView, elementId: this.element.id, element: this.element })
 				}
+			} finally {
 				this.localLoading = false
+				this.isRefreshing = false
 			}
 		},
 	},
diff --git a/src/modules/modals/ViewSettings.vue b/src/modules/modals/ViewSettings.vue
index 0066ab5e0e..d696192f27 100644
--- a/src/modules/modals/ViewSettings.vue
+++ b/src/modules/modals/ViewSettings.vue
@@ -227,8 +227,8 @@ export default {
 					mergedViewSettings.columnSettings = this.view.columnSettings
 				}
 			}
-			if (this.viewSetting.sorting) {
-				mergedViewSettings.sort = [this.viewSetting.sorting[0]]
+			if (Array.isArray(this.viewSetting.sorting) && this.viewSetting.sorting.length > 0) {
+				mergedViewSettings.sort = [...this.viewSetting.sorting]
 			} else {
 				mergedViewSettings.sort = this.view.sort
 			}
diff --git a/src/shared/components/ncTable/NcTable.vue b/src/shared/components/ncTable/NcTable.vue
index 9608c9f3f6..a242ad8c6c 100644
--- a/src/shared/components/ncTable/NcTable.vue
+++ b/src/shared/components/ncTable/NcTable.vue
@@ -43,7 +43,7 @@ deselect-all-rows        -> unselect all rows, e.g. after deleting selected rows
 <template>
 	<div ref="table" class="NcTable" data-cy="ncTable">
 		<div class="options row" style="padding-right: calc(var(--default-grid-baseline) * 2);">
-			<Options v-model:view-setting="localViewSetting" :rows="getSearchedAndFilteredAndSortedRows" :all-rows="rows" :columns="parsedColumns" :element-id="elementId"
+			<Options v-model:view-setting="localViewSetting" :rows="getSearchedRows" :all-rows="rows" :columns="parsedColumns" :element-id="elementId"
 				:is-view="isView"
 				:selected-rows="localSelectedRows"
 				:show-options="parsedColumns.length !== 0" :config="config" @create-row="$emit('create-row')"
@@ -53,7 +53,7 @@ deselect-all-rows        -> unselect all rows, e.g. after deleting selected rows
 		</div>
 		<div class="custom-table row">
 			<CustomTable v-if="config.canReadRows || (config.canCreateRows && rows.length > 0)" v-model:view-setting="localViewSetting"
-				:columns="parsedColumns" :rows="getSearchedAndFilteredAndSortedRows" :is-view="isView" :element-id="elementId"
+				:columns="parsedColumns" :rows="getSearchedRows" :is-view="isView" :element-id="elementId"
 				:config="config" @create-row="$emit('create-row')"
 				@edit-row="rowId => $emit('edit-row', rowId)"
 				@copy-row="rowId => $emit('copy-row', rowId)"
@@ -66,7 +66,7 @@ deselect-all-rows        -> unselect all rows, e.g. after deleting selected rows
 				<template #actions>
 					<slot name="actions"
 						:is-filtered="isFilteredComputed"
-						:on-export-filtered="() => $emit('download-filtered-csv', getSearchedAndFilteredAndSortedRows)" />
+						:on-export-filtered="() => $emit('download-filtered-csv', getSearchedRows)" />
 				</template>
 			</CustomTable>
 			<NcEmptyContent v-else-if="config.canCreateRows && rows.length === 0"
@@ -117,9 +117,6 @@ import {
 	TYPE_META_UPDATED_AT,
 	TYPE_META_UPDATED_BY,
 } from '../../constants.ts'
-import { MetaColumns } from './mixins/metaColumns.js'
-import { MagicFields } from './mixins/magicFields.js'
-import { FilterIds, getFiltersForColumn } from './mixins/filter.js'
 
 export default {
 	name: 'NcTable',
@@ -267,12 +264,9 @@ export default {
 			return (this.localViewSetting?.filter?.length > 0) || !!this.localViewSetting?.searchString
 		},
 
-		sorting() {
-			return this.viewSetting?.sorting
-		},
-		getSearchedAndFilteredRows() {
-			// if we don't have to search and/or filter
-			if (!this.viewSetting?.filter?.length > 0 && !this.viewSetting?.searchString) {
+		getSearchedRows() {
+			// if we don't have to search
+			if (!this.viewSetting?.searchString) {
 				// cleanup markers
 				if (this.rows && this.columns) {
 					this.rows.forEach(row => {
@@ -283,7 +277,6 @@ export default {
 									return
 								}
 								delete cell.searchStringFound
-								delete cell.filterFound
 							})
 						}
 					})
@@ -302,14 +295,11 @@ export default {
 				if (!row || !row.data) {
 					continue
 				}
-				let filterStatusRow = null
 				let searchStatusRow = false
 
 				// each column in a row => cell
 				this.columns.forEach(column => {
-					let filterStatus = null
 					let searchStatus = true
-					const filters = getFiltersForColumn(column, this.viewSetting)
 					let cell
 					if (column.id < 0) {
 						cell = { columnId: column.id }
@@ -343,56 +333,21 @@ export default {
 					}
 					// cleanup possible old markers
 					delete cell.searchStringFound
-					delete cell.filterFound
 
-					// apply filters (if any)
-					filters.forEach(fil => {
-						this.addMagicFieldsValues(fil)
-						if (filterStatus === null || filterStatus === true) {
-							filterStatus = column.isFilterFound(cell, fil)
-						}
-					})
 					// if we should search
 					if (searchString) {
 						searchStatus = column.isSearchStringFound(cell, searchString.toLowerCase())
 					}
 
-					// if filterStatus is null, this result should be ignored
-					if (filterStatus !== null && (filterStatusRow || filterStatusRow === null)) {
-						filterStatusRow = filterStatus
-					}
-
-					// filterStatusRow = filterStatus
 					searchStatusRow = searchStatusRow || searchStatus
 				})
 
-				if ((filterStatusRow || filterStatusRow === null) && searchStatusRow) {
+				if (searchStatusRow) {
 					data.push({ ...row })
 				}
 			}
 			return data
 		},
-		getSearchedAndFilteredAndSortedRows() {
-			const allColumns = this.columns.concat(MetaColumns)
-			const sort = (sortCols) => {
-				const sortColumn = allColumns.find(item => item.id === sortCols?.[0].columnId)
-				const nextSorts = []
-				for (let i = 1; i < sortCols.length; i++) {
-					const sortColumn = allColumns.find(item => item.id === sortCols[i].columnId)
-					nextSorts.push(sortColumn?.sort?.(sortCols[i].mode))
-				}
-				return [...this.getSearchedAndFilteredRows].sort(sortColumn?.sort?.(sortCols[0].mode, nextSorts))
-			}
-
-			// if we have to sort
-			if (this.viewSetting?.presetSorting) {
-				return sort(this.viewSetting.presetSorting)
-			}
-			if (this.viewSetting?.sorting) {
-				return sort(this.viewSetting.sorting)
-			}
-			return this.getSearchedAndFilteredRows
-		},
 	},
 	watch: {
 		localSelectedRows() {
@@ -434,18 +389,6 @@ export default {
 			this.localViewSetting.searchString = str !== '' ? str : null
 			this.localViewSetting = JSON.parse(JSON.stringify(this.localViewSetting))
 		},
-		addMagicFieldsValues(filter) {
-			if (FilterIds.ContainsItem === filter.operator.id) {
-				return
-			}
-
-			Object.values(MagicFields).forEach(field => {
-				const newFilterValue = filter.value.replace('@' + field.id, field.replace)
-				if (filter.value !== newFilterValue) {
-					filter.magicValuesEnriched = newFilterValue
-				}
-			})
-		},
 	},
 }
 </script>
diff --git a/src/shared/components/ncTable/mixins/columnClass.js b/src/shared/components/ncTable/mixins/columnClass.js
index 95250ccc18..8ab34f54fc 100644
--- a/src/shared/components/ncTable/mixins/columnClass.js
+++ b/src/shared/components/ncTable/mixins/columnClass.js
@@ -26,23 +26,6 @@ export class AbstractColumn {
 		this.customSettings = data.customSettings
 	}
 
-	canSort() {
-		return typeof this.sort === 'function'
-	}
-
-	getNextSortsResult(nextSorts, rowA, rowB) {
-		if (!nextSorts) {
-			return 0
-		}
-		for (const sort of nextSorts) {
-			const result = sort(rowA, rowB)
-			if (result !== 0) {
-				return result
-			}
-		}
-		return 0
-	}
-
 	getPossibleOperators() {
 		return Object.values(Filters).filter(fil => fil.goodFor.includes(this.type))
 	}
diff --git a/src/shared/components/ncTable/mixins/columnsTypes/datetime.js b/src/shared/components/ncTable/mixins/columnsTypes/datetime.js
index e4d32af108..8dc3d12a21 100644
--- a/src/shared/components/ncTable/mixins/columnsTypes/datetime.js
+++ b/src/shared/components/ncTable/mixins/columnsTypes/datetime.js
@@ -6,10 +6,6 @@ import { AbstractDatetimeColumn } from '../columnClass.js'
 import { ColumnTypes } from '../columnHandler.js'
 import Moment from '@nextcloud/moment'
 import { FilterIds } from '../filter.js'
-import {
-	TYPE_META_CREATED_AT,
-	TYPE_META_UPDATED_AT,
-} from '../../../../constants.ts'
 
 export default class DatetimeColumn extends AbstractDatetimeColumn {
 
@@ -22,36 +18,6 @@ export default class DatetimeColumn extends AbstractDatetimeColumn {
 		return Moment(value, 'YYYY-MM-DD HH:mm:ss').format('lll')
 	}
 
-	sort(mode, nextSorts) {
-		const factor = mode === 'DESC' ? -1 : 1
-		return (rowA, rowB) => {
-			let tmpA = rowA.data.find(item => item.columnId === this.id)?.value || ''
-			let tmpB = rowB.data.find(item => item.columnId === this.id)?.value || ''
-			if (this.id === TYPE_META_CREATED_AT) {
-				tmpA = rowA.createdAt
-				tmpB = rowB.createdAt
-			}
-			if (this.id === TYPE_META_UPDATED_AT) {
-				tmpA = rowA.lastEditAt
-				tmpB = rowB.lastEditAt
-			}
-
-			if (!tmpA && tmpB) {
-				return -1 * factor
-			}
-			if (tmpA && !tmpB) {
-				return 1 * factor
-			}
-			if (!tmpA && !tmpB) {
-				return super.getNextSortsResult(nextSorts, rowA, rowB)
-			}
-
-			const valueA = new Moment(tmpA, 'YYYY-MM-DD HH:mm')
-			const valueB = new Moment(tmpB, 'YYYY-MM-DD HH:mm')
-			return (valueA.diff(valueB)) * factor || super.getNextSortsResult(nextSorts, rowA, rowB)
-		}
-	}
-
 	isSearchStringFound(cell, searchString) {
 		const date = new Moment(cell.value, 'YYYY-MM-DD HH:mm').format('lll')
 		return super.isSearchStringFound(date, cell, searchString)
diff --git a/src/shared/components/ncTable/mixins/columnsTypes/datetimeDate.js b/src/shared/components/ncTable/mixins/columnsTypes/datetimeDate.js
index db3d9cf6d6..e20fdd4583 100644
--- a/src/shared/components/ncTable/mixins/columnsTypes/datetimeDate.js
+++ b/src/shared/components/ncTable/mixins/columnsTypes/datetimeDate.js
@@ -18,26 +18,6 @@ export default class DatetimeDateColumn extends AbstractDatetimeColumn {
 		return Moment(value, 'YYYY-MM-DD HH:mm:ss').format('ll')
 	}
 
-	sort(mode, nextSorts) {
-		const factor = mode === 'DESC' ? -1 : 1
-		return (rowA, rowB) => {
-			const tmpA = rowA.data.find(item => item.columnId === this.id)?.value || ''
-			const valueA = new Moment(tmpA)
-			const tmpB = rowB.data.find(item => item.columnId === this.id)?.value || ''
-			const valueB = new Moment(tmpB)
-			if (!tmpA && tmpB) {
-				return -1 * factor
-			}
-			if (tmpA && !tmpB) {
-				return 1 * factor
-			}
-			if (!tmpA && !tmpB) {
-				return super.getNextSortsResult(nextSorts, rowA, rowB)
-			}
-			return (valueA.diff(valueB)) * factor || super.getNextSortsResult(nextSorts, rowA, rowB)
-		}
-	}
-
 	isSearchStringFound(cell, searchString) {
 		const date = new Moment(cell.value, 'YYYY-MM-DD').format('ll')
 		return super.isSearchStringFound(date, cell, searchString)
diff --git a/src/shared/components/ncTable/mixins/columnsTypes/datetimeTime.js b/src/shared/components/ncTable/mixins/columnsTypes/datetimeTime.js
index 04dc8a3a97..394b49bc6d 100644
--- a/src/shared/components/ncTable/mixins/columnsTypes/datetimeTime.js
+++ b/src/shared/components/ncTable/mixins/columnsTypes/datetimeTime.js
@@ -18,26 +18,6 @@ export default class DatetimeTimeColumn extends AbstractDatetimeColumn {
 		return Moment(value, 'HH:mm:ss').format('LT')
 	}
 
-	sort(mode, nextSorts) {
-		const factor = mode === 'DESC' ? -1 : 1
-		return (rowA, rowB) => {
-			const tmpA = rowA.data.find(item => item.columnId === this.id)?.value || ''
-			const valueA = new Moment(tmpA, 'HH:mm')
-			const tmpB = rowB.data.find(item => item.columnId === this.id)?.value || ''
-			const valueB = new Moment(tmpB, 'HH:mm')
-			if (!tmpA && tmpB) {
-				return -1 * factor
-			}
-			if (tmpA && !tmpB) {
-				return 1 * factor
-			}
-			if (!tmpA && !tmpB) {
-				return super.getNextSortsResult(nextSorts, rowA, rowB)
-			}
-			return (valueA.diff(valueB)) * factor || super.getNextSortsResult(nextSorts, rowA, rowB)
-		}
-	}
-
 	isSearchStringFound(cell, searchString) {
 		const time = new Moment(cell.value, 'YYYY-MM-DD HH:mm').format('lll')
 		return super.isSearchStringFound(time, cell, searchString)
diff --git a/src/shared/components/ncTable/mixins/columnsTypes/number.js b/src/shared/components/ncTable/mixins/columnsTypes/number.js
index b343817351..2ff7c51361 100644
--- a/src/shared/components/ncTable/mixins/columnsTypes/number.js
+++ b/src/shared/components/ncTable/mixins/columnsTypes/number.js
@@ -5,8 +5,6 @@
 import { AbstractNumberColumn } from '../columnClass.js'
 import { ColumnTypes } from '../columnHandler.js'
 import { FilterIds } from '../filter.js'
-import { TYPE_META_ID } from '../../../../constants.ts'
-
 export default class NumberColumn extends AbstractNumberColumn {
 
 	constructor(data) {
@@ -19,28 +17,6 @@ export default class NumberColumn extends AbstractNumberColumn {
 		this.numberSuffix = data.numberSuffix
 	}
 
-	sort(mode, nextSorts) {
-		const factor = mode === 'DESC' ? -1 : 1
-		return (rowA, rowB) => {
-			let valueA = rowA.data.find(item => item.columnId === this.id)?.value || null
-			let valueB = rowB.data.find(item => item.columnId === this.id)?.value || null
-			if (this.id === TYPE_META_ID) {
-				valueA = rowA.id
-				valueB = rowB.id
-			}
-			if (!valueA && valueB) {
-				return -1 * factor
-			}
-			if (valueA && !valueB) {
-				return 1 * factor
-			}
-			if (!valueA && !valueB) {
-				return super.getNextSortsResult(nextSorts, rowA, rowB)
-			}
-			return ((valueA < valueB) ? -1 : (valueA > valueB) ? 1 : 0) * factor || super.getNextSortsResult(nextSorts, rowA, rowB)
-		}
-	}
-
 	isSearchStringFound(cell, searchString) {
 		return super.isSearchStringFound(('' + cell.value), cell, searchString)
 	}
diff --git a/src/shared/components/ncTable/mixins/columnsTypes/numberProgress.js b/src/shared/components/ncTable/mixins/columnsTypes/numberProgress.js
index a391c62ddd..d692daefab 100644
--- a/src/shared/components/ncTable/mixins/columnsTypes/numberProgress.js
+++ b/src/shared/components/ncTable/mixins/columnsTypes/numberProgress.js
@@ -13,17 +13,6 @@ export default class NumberProgressColumn extends AbstractNumberColumn {
 		this.type = ColumnTypes.NumberProgress
 	}
 
-	sort(mode, nextSorts) {
-		const factor = mode === 'DESC' ? -1 : 1
-		return (rowA, rowB) => {
-			const tmpA = rowA.data.find(item => item.columnId === this.id)?.value || 0
-			const valueA = parseInt(tmpA)
-			const tmpB = rowB.data.find(item => item.columnId === this.id)?.value || 0
-			const valueB = parseInt(tmpB)
-			return ((valueA < valueB) ? -1 : (valueA > valueB) ? 1 : 0) * factor || super.getNextSortsResult(nextSorts, rowA, rowB)
-		}
-	}
-
 	isSearchStringFound(cell, searchString) {
 		return super.isSearchStringFound(('' + cell.value), cell, searchString)
 	}
diff --git a/src/shared/components/ncTable/mixins/columnsTypes/numberStars.js b/src/shared/components/ncTable/mixins/columnsTypes/numberStars.js
index 754d9f3aea..5dd4171e59 100644
--- a/src/shared/components/ncTable/mixins/columnsTypes/numberStars.js
+++ b/src/shared/components/ncTable/mixins/columnsTypes/numberStars.js
@@ -13,17 +13,6 @@ export default class NumberStarsColumn extends AbstractNumberColumn {
 		this.type = ColumnTypes.NumberStars
 	}
 
-	sort(mode, nextSorts) {
-		const factor = mode === 'DESC' ? -1 : 1
-		return (rowA, rowB) => {
-			const tmpA = rowA.data.find(item => item.columnId === this.id)?.value
-			const valueA = Number.isNaN(parseInt(tmpA)) ? -1 : parseInt(tmpA)
-			const tmpB = rowB.data.find(item => item.columnId === this.id)?.value
-			const valueB = Number.isNaN(parseInt(tmpB)) ? -1 : parseInt(tmpB)
-			return ((valueA < valueB) ? -1 : (valueA > valueB) ? 1 : 0) * factor || super.getNextSortsResult(nextSorts, rowA, rowB)
-		}
-	}
-
 	isSearchStringFound(cell, searchString) {
 		return super.isSearchStringFound(('' + cell.value), cell, searchString)
 	}
diff --git a/src/shared/components/ncTable/mixins/columnsTypes/selection.js b/src/shared/components/ncTable/mixins/columnsTypes/selection.js
index 31d3f9a31a..4a211c5136 100644
--- a/src/shared/components/ncTable/mixins/columnsTypes/selection.js
+++ b/src/shared/components/ncTable/mixins/columnsTypes/selection.js
@@ -29,19 +29,6 @@ export default class SelectionColumn extends AbstractSelectionColumn {
 		return !!this.selectionOptions[i]?.deleted
 	}
 
-	sort(mode, nextSorts) {
-		const factor = mode === 'DESC' ? -1 : 1
-		return (rowA, rowB) => {
-			const selectionIdA = parseInt(rowA.data.find(item => item.columnId === this.id)?.value)
-			const vA = Number.isNaN(selectionIdA) ? '' : this.selectionOptions.find(item => item.id === selectionIdA)?.label
-			const valueA = this.removeEmoji(vA).trim()
-			const selectionIdB = parseInt(rowB.data.find(item => item.columnId === this.id)?.value ?? null)
-			const vB = Number.isNaN(selectionIdB) ? '' : this.selectionOptions.find(item => item.id === selectionIdB)?.label
-			const valueB = this.removeEmoji(vB).trim()
-			return ((valueA < valueB) ? -1 : (valueA > valueB) ? 1 : 0) * factor || super.getNextSortsResult(nextSorts, rowA, rowB)
-		}
-	}
-
 	removeEmoji(str) {
 		return str.replace(/([#0-9]\u20E3)|[\xA9\xAE\u203C\u2047-\u2049\u2122\u2139\u3030\u303D\u3297\u3299][\uFE00-\uFEFF]?|[\u2190-\u21FF][\uFE00-\uFEFF]?|[\u2300-\u23FF][\uFE00-\uFEFF]?|[\u2460-\u24FF][\uFE00-\uFEFF]?|[\u25A0-\u25FF][\uFE00-\uFEFF]?|[\u2600-\u27BF][\uFE00-\uFEFF]?|[\u2900-\u297F][\uFE00-\uFEFF]?|[\u2B00-\u2BF0][\uFE00-\uFEFF]?|(?:\uD83C[\uDC00-\uDFFF]|\uD83D[\uDC00-\uDEFF])[\uFE00-\uFEFF]?/g, '')
 	}
diff --git a/src/shared/components/ncTable/mixins/columnsTypes/selectionCheck.js b/src/shared/components/ncTable/mixins/columnsTypes/selectionCheck.js
index e4730406b4..080ea8f234 100644
--- a/src/shared/components/ncTable/mixins/columnsTypes/selectionCheck.js
+++ b/src/shared/components/ncTable/mixins/columnsTypes/selectionCheck.js
@@ -13,17 +13,6 @@ export default class SelectionCheckColumn extends AbstractSelectionColumn {
 		this.type = ColumnTypes.SelectionCheck
 	}
 
-	sort(mode, nextSorts) {
-		const factor = mode === 'DESC' ? -1 : 1
-		return (rowA, rowB) => {
-			const tmpA = rowA.data.find(item => item.columnId === this.id)?.value || ''
-			const valueA = (tmpA === true || tmpA === 'true')
-			const tmpB = rowB.data.find(item => item.columnId === this.id)?.value || ''
-			const valueB = (tmpB === true || tmpB === 'true')
-			return (valueA - valueB) * factor || super.getNextSortsResult(nextSorts, rowA, rowB)
-		}
-	}
-
 	isSearchStringFound(cell, searchString) {
 		return false
 	}
diff --git a/src/shared/components/ncTable/mixins/columnsTypes/textLine.js b/src/shared/components/ncTable/mixins/columnsTypes/textLine.js
index e1408f225f..6d574330c2 100644
--- a/src/shared/components/ncTable/mixins/columnsTypes/textLine.js
+++ b/src/shared/components/ncTable/mixins/columnsTypes/textLine.js
@@ -5,7 +5,6 @@
 import { AbstractTextColumn } from '../columnClass.js'
 import { ColumnTypes } from '../columnHandler.js'
 import { FilterIds } from '../filter.js'
-import { TYPE_META_CREATED_BY, TYPE_META_UPDATED_BY } from '../../../../constants.ts'
 
 export default class TextLineColumn extends AbstractTextColumn {
 
@@ -16,23 +15,6 @@ export default class TextLineColumn extends AbstractTextColumn {
 		this.textUnique = data.textUnique
 	}
 
-	sort(mode, nextSorts) {
-		const factor = mode === 'DESC' ? -1 : 1
-		return (rowA, rowB) => {
-			let valueA = rowA.data.find(item => item.columnId === this.id)?.value?.toLowerCase() || ''
-			let valueB = rowB.data.find(item => item.columnId === this.id)?.value?.toLowerCase() || ''
-			if (this.id === TYPE_META_CREATED_BY) {
-				valueA = rowA.createdBy?.toLowerCase() || ''
-				valueB = rowB.createdBy?.toLowerCase() || ''
-			}
-			if (this.id === TYPE_META_UPDATED_BY) {
-				valueA = rowA.lastEditBy?.toLowerCase() || ''
-				valueB = rowB.lastEditBy?.toLowerCase() || ''
-			}
-			return valueA.localeCompare(valueB, undefined) * factor || super.getNextSortsResult(nextSorts, rowA, rowB)
-		}
-	}
-
 	getValueString(valueObject) {
 		return valueObject.value.replace(/(<([^>]+)>)/ig, '')
 	}
diff --git a/src/shared/components/ncTable/mixins/columnsTypes/textLink.js b/src/shared/components/ncTable/mixins/columnsTypes/textLink.js
index e0328f68f5..312b65a304 100644
--- a/src/shared/components/ncTable/mixins/columnsTypes/textLink.js
+++ b/src/shared/components/ncTable/mixins/columnsTypes/textLink.js
@@ -14,17 +14,6 @@ export default class TextLinkColumn extends AbstractTextColumn {
 		this.textAllowedPattern = data.textAllowedPattern
 	}
 
-	sort(mode, nextSorts) {
-		const factor = mode === 'DESC' ? -1 : 1
-		return (rowA, rowB) => {
-			const tmpA = rowA.data.find(item => item.columnId === this.id)?.value?.toLowerCase() || ''
-			const valueA = this.getValueFromCellValue(tmpA)
-			const tmpB = rowB.data.find(item => item.columnId === this.id)?.value?.toLowerCase() || ''
-			const valueB = this.getValueFromCellValue(tmpB)
-			return valueA.localeCompare(valueB, undefined) * factor || super.getNextSortsResult(nextSorts, rowA, rowB)
-		}
-	}
-
 	getValueFromCellValue(cellValue) {
 		// check if the value is the old string or the new object
 		try {
diff --git a/src/shared/components/ncTable/mixins/filter.js b/src/shared/components/ncTable/mixins/filter.js
index e3a4cf9655..d1b3df0712 100644
--- a/src/shared/components/ncTable/mixins/filter.js
+++ b/src/shared/components/ncTable/mixins/filter.js
@@ -74,27 +74,27 @@ export const Filters = {
 	BeginsWith: new Filter({
 		id: FilterIds.BeginsWith,
 		label: t('tables', 'Begins with'),
-		goodFor: [ColumnTypes.TextLine, ColumnTypes.TextLink],
+		goodFor: [ColumnTypes.TextLine],
 		incompatibleWith: [FilterIds.IsEmpty, FilterIds.IsEqual, FilterIds.BeginsWith],
 	}),
 	EndsWith: new Filter({
 		id: FilterIds.EndsWith,
 		label: t('tables', 'Ends with'),
-		goodFor: [ColumnTypes.TextLine, ColumnTypes.TextLink],
+		goodFor: [ColumnTypes.TextLine],
 		incompatibleWith: [FilterIds.IsEmpty, FilterIds.IsEqual, FilterIds.EndsWith],
 	}),
 	IsEqual: new Filter({
 		id: FilterIds.IsEqual,
 		label: t('tables', 'Is equal'),
 		shortLabel: '=',
-		goodFor: [ColumnTypes.TextLine, ColumnTypes.Number, ColumnTypes.SelectionCheck, ColumnTypes.TextLink, ColumnTypes.NumberStars, ColumnTypes.NumberProgress, ColumnTypes.DatetimeDate, ColumnTypes.DatetimeTime, ColumnTypes.Datetime, ColumnTypes.Selection, ColumnTypes.SelectionMulti, ColumnTypes.Usergroup, ColumnTypes.Relation],
+		goodFor: [ColumnTypes.TextLine, ColumnTypes.Number, ColumnTypes.SelectionCheck, ColumnTypes.NumberStars, ColumnTypes.NumberProgress, ColumnTypes.DatetimeDate, ColumnTypes.DatetimeTime, ColumnTypes.Datetime, ColumnTypes.Selection, ColumnTypes.SelectionMulti, ColumnTypes.Usergroup, ColumnTypes.Relation],
 		incompatibleWith: [FilterIds.IsNotEqual, FilterIds.IsEmpty, FilterIds.IsEqual, FilterIds.BeginsWith, FilterIds.EndsWith, FilterIds.Contains, FilterIds.IsGreaterThan, FilterIds.IsGreaterThanOrEqual, FilterIds.IsLowerThan, FilterIds.IsLowerThanOrEqual],
 	}),
 	IsNotEqual: new Filter({
 		id: FilterIds.IsNotEqual,
 		label: t('tables', 'Is not equal'),
 		shortLabel: '!=',
-		goodFor: [ColumnTypes.TextLine, ColumnTypes.Number, ColumnTypes.SelectionCheck, ColumnTypes.TextLink, ColumnTypes.NumberStars, ColumnTypes.NumberProgress, ColumnTypes.DatetimeDate, ColumnTypes.DatetimeTime, ColumnTypes.Datetime, ColumnTypes.Selection, ColumnTypes.SelectionMulti, ColumnTypes.Usergroup, ColumnTypes.Relation],
+		goodFor: [ColumnTypes.TextLine, ColumnTypes.Number, ColumnTypes.SelectionCheck, ColumnTypes.NumberStars, ColumnTypes.NumberProgress, ColumnTypes.DatetimeDate, ColumnTypes.DatetimeTime, ColumnTypes.Datetime, ColumnTypes.Selection, ColumnTypes.SelectionMulti, ColumnTypes.Usergroup, ColumnTypes.Relation],
 		incompatibleWith: [FilterIds.IsEmpty, FilterIds.IsEqual, FilterIds.BeginsWith, FilterIds.EndsWith, FilterIds.Contains, FilterIds.IsGreaterThan, FilterIds.IsGreaterThanOrEqual, FilterIds.IsLowerThan, FilterIds.IsLowerThanOrEqual],
 	}),
 	IsGreaterThan: new Filter({
diff --git a/src/shared/components/ncTable/mixins/filterSupport.js b/src/shared/components/ncTable/mixins/filterSupport.js
new file mode 100644
index 0000000000..18d540fb72
--- /dev/null
+++ b/src/shared/components/ncTable/mixins/filterSupport.js
@@ -0,0 +1,128 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * Backend filter query support
+ */
+import { TYPE_SELECTION } from '../../../constants.ts'
+import { FilterIds } from './filter.js'
+
+// Return a column object for a given id. For meta columns, which are not in
+// `this.columns`, return a small fallback object.
+export function getColumnForFilter(columns = [], columnId) {
+	return (columns || []).find(col => col.id === columnId) ?? { id: columnId, type: null }
+}
+
+export function parseBackendFilterGroups(customFiltersString) {
+	if (!customFiltersString) {
+		return []
+	}
+
+	try {
+		const parsed = JSON.parse(customFiltersString)
+		if (!Array.isArray(parsed)) {
+			return []
+		}
+
+		// URL query data can be invalid, so keep only filter groups and rules that
+		// match the backend format we expect.
+		return parsed
+			.filter(group => Array.isArray(group))
+			.map(group => group
+				.filter(rule => rule && typeof rule === 'object')
+				.filter(rule => Number.isInteger(Number.parseInt(rule.columnId, 10)) && typeof rule.operator === 'string')
+				.map(rule => ({
+					columnId: Number.parseInt(rule.columnId, 10),
+					operator: rule.operator,
+					value: rule.value ?? '',
+				})))
+			.filter(group => group.length > 0)
+	} catch (error) {
+		return []
+	}
+}
+// Convert filters currently stored in the page UI into backend filter groups.
+export function normalizeRuntimeFilterGroups(runtimeFilters = [], columns = []) {
+	if (!Array.isArray(runtimeFilters) || runtimeFilters.length === 0) {
+		return []
+	}
+
+	// The UI stores filters as one flat list. The backend expects groups, where
+	// every rule inside one group must match.
+	let groups = [[]]
+
+	for (const filter of runtimeFilters) {
+		if (!filter || typeof filter !== 'object') {
+			continue
+		}
+
+		const columnId = Number.parseInt(filter.columnId, 10)
+		if (!Number.isInteger(columnId)) {
+			continue
+		}
+
+		const operatorId = filter?.operator?.id
+		if (!operatorId) {
+			continue
+		}
+
+		if (operatorId === FilterIds.ContainsItem) {
+			const selectedOptions = Array.isArray(filter.value) ? filter.value : []
+			if (selectedOptions.length === 0) {
+				continue
+			}
+
+			const columnType = getColumnForFilter(columns, columnId)?.type
+			// A "contains item" filter can match several selected values, so expand
+			// it into several backend rules and keep them as alternatives.
+			const translatedRules = selectedOptions
+				.map(option => option?.id)
+				.filter(optionId => optionId !== null && optionId !== undefined)
+				.map(optionId => ({
+					columnId,
+					operator: columnType === TYPE_SELECTION ? FilterIds.IsEqual : FilterIds.Contains,
+					value: optionId,
+				}))
+
+			if (translatedRules.length === 0) {
+				continue
+			}
+
+			// Normal filters must all match together, so add the rule to every group.
+			groups = groups.flatMap(group => translatedRules.map(rule => [...group, rule]))
+			continue
+		}
+
+		const normalizedRule = {
+			columnId,
+			operator: operatorId,
+			value: filter.value ?? '',
+		}
+		groups = groups.map(group => [...group, normalizedRule])
+	}
+
+	return groups.filter(group => group.length > 0)
+}
+
+// This is used to merge URL filters with filters added in the current UI.
+export function mergeBackendFilterGroups(leftGroups, rightGroups) {
+	if (leftGroups.length === 0) {
+		return rightGroups
+	}
+
+	if (rightGroups.length === 0) {
+		return leftGroups
+	}
+
+	// Keep both sets of groups active at the same time by combining every left
+	// group with every right group.
+	return leftGroups.flatMap(leftGroup => rightGroups.map(rightGroup => [...leftGroup, ...rightGroup]))
+}
+
+export function buildBackendFilterQuery(customFiltersString, viewSetting = {}, columns = []) {
+	const routeCustomFilters = parseBackendFilterGroups(customFiltersString)
+	const runtimeFilterGroups = normalizeRuntimeFilterGroups(viewSetting?.filter, columns)
+	const mergedCustomFilters = mergeBackendFilterGroups(routeCustomFilters, runtimeFilterGroups)
+
+	return mergedCustomFilters.length > 0 ? JSON.stringify(mergedCustomFilters) : null
+}
diff --git a/src/shared/components/ncTable/mixins/sortSupport.js b/src/shared/components/ncTable/mixins/sortSupport.js
new file mode 100644
index 0000000000..c9dc08d56b
--- /dev/null
+++ b/src/shared/components/ncTable/mixins/sortSupport.js
@@ -0,0 +1,99 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import {
+	TYPE_META_CREATED_AT,
+	TYPE_META_CREATED_BY,
+	TYPE_META_ID,
+	TYPE_META_UPDATED_AT,
+	TYPE_META_UPDATED_BY,
+	TYPE_DATETIME,
+	TYPE_DATETIME_DATE,
+	TYPE_DATETIME_TIME,
+	TYPE_NUMBER,
+	TYPE_NUMBER_PROGRESS,
+	TYPE_NUMBER_STARS,
+	TYPE_TEXT_LINK,
+	TYPE_SELECTION,
+	TYPE_SELECTION_MULTI,
+	TYPE_TEXT_LINE,
+} from '../../../constants.ts'
+
+export const BACKEND_SORTABLE_TYPES = new Set([
+	TYPE_TEXT_LINE,
+	TYPE_TEXT_LINK,
+	TYPE_SELECTION,
+	TYPE_SELECTION_MULTI,
+	TYPE_NUMBER,
+	TYPE_NUMBER_STARS,
+	TYPE_NUMBER_PROGRESS,
+	TYPE_DATETIME_DATE,
+	TYPE_DATETIME_TIME,
+	TYPE_DATETIME,
+])
+
+export function getBackendSortableColumnType(columnId, columnType = null) {
+	// Meta columns reuse backend scalar sort behavior based on their stored row fields.
+	if (columnId === TYPE_META_ID) {
+		return TYPE_NUMBER
+	}
+
+	if (columnId === TYPE_META_CREATED_BY || columnId === TYPE_META_UPDATED_BY) {
+		return TYPE_TEXT_LINE
+	}
+
+	if (columnId === TYPE_META_CREATED_AT || columnId === TYPE_META_UPDATED_AT) {
+		return TYPE_DATETIME
+	}
+
+	return columnType
+}
+
+export function isBackendSortableColumn({ id, type }) {
+	if (id < 0) {
+		return true
+	}
+
+	return BACKEND_SORTABLE_TYPES.has(getBackendSortableColumnType(id, type))
+}
+
+export function getColumnForSort(columns = [], columnId) {
+	return (columns || []).find(col => col.id === columnId) ?? { id: columnId, type: null }
+}
+
+export function isBackendSortableRule(rule, columns = []) {
+	const normalizedRule = normalizeBackendSortRules([rule])[0]
+	if (!normalizedRule) {
+		return false
+	}
+
+	return isBackendSortableColumn(getColumnForSort(columns, normalizedRule.columnId))
+}
+
+export function normalizeBackendSortRules(sortRules = []) {
+	if (!Array.isArray(sortRules)) {
+		return []
+	}
+
+	// Keep the request contract narrow so unsupported UI state never reaches the backend.
+	return sortRules
+		.map(rule => ({
+			columnId: Number.parseInt(rule?.columnId, 10),
+			mode: rule?.mode === 'DESC' ? 'DESC' : 'ASC',
+		}))
+		.filter(rule => Number.isInteger(rule.columnId))
+}
+
+export function normalizeBackendSortRulesForColumns(sortRules = [], columns = []) {
+	return normalizeBackendSortRules(sortRules)
+		.filter(rule => isBackendSortableColumn(getColumnForSort(columns, rule.columnId)))
+}
+
+export function getExplicitSortRules(viewSetting = {}) {
+	if (Array.isArray(viewSetting?.sorting) && viewSetting.sorting.length > 0) {
+		return viewSetting.sorting
+	}
+
+	return []
+}
diff --git a/src/shared/components/ncTable/partials/FilterLabel.vue b/src/shared/components/ncTable/partials/FilterLabel.vue
index 6e7fd328c6..297b11f5f9 100644
--- a/src/shared/components/ncTable/partials/FilterLabel.vue
+++ b/src/shared/components/ncTable/partials/FilterLabel.vue
@@ -30,6 +30,10 @@ export default {
 		      type: [String, Array],
 		      default: '',
 		    },
+		displayValue: {
+		      type: String,
+		      default: null,
+		    },
 		type: {
 		      type: String,
 		      default: 'highlighted', // highlighted, outlined
@@ -45,11 +49,18 @@ export default {
 	],
 	computed: {
 		getValue() {
+			if (this.displayValue) {
+				return this.displayValue
+			}
+
 			if (FilterIds.ContainsItem === this.operator.id) {
 				return this.value
 			}
 
 			let value = this.value
+			if (typeof value !== 'string') {
+				return value
+			}
 			Object.values(MagicFields).forEach(field => {
 				value = value.replace('@' + field.id, field.label)
 			})
diff --git a/src/shared/components/ncTable/partials/TableHeader.vue b/src/shared/components/ncTable/partials/TableHeader.vue
index ec86961524..5bd8ea8a5f 100644
--- a/src/shared/components/ncTable/partials/TableHeader.vue
+++ b/src/shared/components/ncTable/partials/TableHeader.vue
@@ -43,6 +43,7 @@
 							:key="filter.columnId + filter.operator.id+ filter.value"
 							:operator="castToFilter(filter.operator.id)"
 							:value="filter.value"
+							:display-value="filter.displayValue"
 							@delete-filter="id => deleteFilter(id)" />
 					</div>
 				</div>
diff --git a/src/shared/components/ncTable/partials/TableHeaderColumnOptions.vue b/src/shared/components/ncTable/partials/TableHeaderColumnOptions.vue
index 7b4968bd21..0e0aaa9f15 100644
--- a/src/shared/components/ncTable/partials/TableHeaderColumnOptions.vue
+++ b/src/shared/components/ncTable/partials/TableHeaderColumnOptions.vue
@@ -42,7 +42,7 @@
 						v-model="searchOptions"
 						type="multiselect"
 						:multiple="true"
-						:options="column.selectionOptions"
+						:options="selectionFilterOptions"
 						:placeholder="t('tables', 'Select options')" />
 					<NcActionButton
 						:close-after-click="true"
@@ -53,6 +53,22 @@
 						{{ t('tables', 'Submit') }}
 					</NcActionButton>
 				</template>
+				<template v-else-if="shouldUseOptionInput">
+					<NcActionInput
+						v-model="searchOption"
+						type="multiselect"
+						:multiple="false"
+						:options="filterOptions"
+						:placeholder="optionInputPlaceholder" />
+					<NcActionButton
+						:close-after-click="true"
+						@click="submitFilterInput()">
+						<template #icon>
+							<Magnify :size="20" />
+						</template>
+						{{ t('tables', 'Submit') }}
+					</NcActionButton>
+				</template>
 
 				<NcActionInput
 					v-else
@@ -88,8 +104,8 @@
 					</template>
 					{{ pinnedColumnId === column.id ? t('tables', 'Unpin column') : t('tables', 'Pin column') }}
 				</NcActionButton>
-				<NcActionCaption v-if="!hasPresetSorting && canSort" :name="t('tables', 'Sorting')" />
-				<NcActionButtonGroup v-if="!hasPresetSorting && canSort">
+				<NcActionCaption v-if="canSort" :name="t('tables', 'Sorting')" />
+				<NcActionButtonGroup v-if="canSort">
 					<NcActionButton :class="{ selected: getSortMode === 'ASC' }" :aria-label="t('tables', 'Sort asc')" @click="sort('ASC')">
 						<template #icon>
 							<SortAsc :size="20" />
@@ -172,7 +188,10 @@ import {
 } from '@nextcloud/vue'
 import { AbstractColumn } from '../mixins/columnClass.js'
 import { FilterIds } from '../mixins/filter.js'
+import { isBackendSortableColumn } from '../mixins/sortSupport.js'
 import { translate as t } from '@nextcloud/l10n'
+import { useDataStore } from '../../../../store/data.js'
+import { useTablesStore } from '../../../../store/store.js'
 
 export default {
 	components: {
@@ -226,9 +245,9 @@ export default {
 	data() {
 		return {
 			searchValue: '',
+			searchOption: null,
 			searchOptions: [],
 			operator: null,
-			sortMode: null,
 			term: '',
 			selectOperator: false,
 			selectValue: false,
@@ -272,14 +291,53 @@ export default {
 		getMagicFields() {
 			return this.column.getPossibleMagicFields()
 		},
-		canSort() {
-			return this.column.canSort()
+		isSelectionColumn() {
+			return ['selection', 'selection-multi'].includes(this.column?.type)
+		},
+		isRelationColumn() {
+			return this.column?.type === 'relation'
+		},
+		shouldUseOptionInput() {
+			return (this.isSelectionColumn || this.isRelationColumn) && !this.selectedOperator?.noSearchValue
+		},
+		selectionFilterOptions() {
+			return (this.column?.selectionOptions ?? [])
+				.filter(option => !option.deleted)
+				.map(option => ({
+					id: '@selection-id-' + option.id,
+					label: option.label,
+				}))
+		},
+		relationFilterOptions() {
+			const dataStore = useDataStore()
+			const columnRelations = dataStore.getRelations(this.column?.id)?.data
+			return Object.values(columnRelations ?? {})
+				.map(option => ({
+					id: '@relation-id-' + option.id,
+					label: option.label,
+				}))
+		},
+		filterOptions() {
+			if (this.isRelationColumn) {
+				return this.relationFilterOptions
+			}
+			return this.selectionFilterOptions
+		},
+		optionInputPlaceholder() {
+			if (this.isRelationColumn) {
+				return t('tables', 'Select relation value')
+			}
+			return t('tables', 'Select option')
 		},
-		hasPresetSorting() {
-			return this.localViewSetting?.presetSorting?.find(item => item.columnId === this.column?.id)
+		canSort() {
+			return isBackendSortableColumn(this.column)
 		},
 		getSortMode() {
-			const sortObject = this.localViewSetting?.presetSorting?.find(item => item.columnId === this.column?.id) ?? this.localViewSetting?.sorting?.find(item => item.columnId === this.column?.id)
+			if (Array.isArray(this.localViewSetting?.sorting)) {
+				return this.localViewSetting.sorting.find(item => item.columnId === this.column?.id)?.mode ?? null
+			}
+
+			const sortObject = this.localViewSetting?.presetSorting?.find(item => item.columnId === this.column?.id)
 			if (sortObject) {
 				return sortObject.mode
 			}
@@ -341,9 +399,27 @@ export default {
 	},
 	created() {
 		this.reset()
+		this.loadRelationOptions()
 	},
 	methods: {
 		t,
+		loadRelationOptions() {
+			if (!this.isRelationColumn) {
+				return
+			}
+
+			const tablesStore = useTablesStore()
+			const dataStore = useDataStore()
+			const activeElement = tablesStore.activeView || tablesStore.activeTable
+			if (!activeElement) {
+				return
+			}
+
+			dataStore.loadRelationsFromBE({
+				tableId: tablesStore.activeTable?.id,
+				viewId: tablesStore.activeView?.id,
+			})
+		},
 		isDisabled(op) {
 			return this.getDisabledOperators.map(o => o.id).includes(op)
 		},
@@ -369,13 +445,19 @@ export default {
 			}
 		},
 		submitFilterInput() {
+			const filterValue = this.getFilterValue()
+			if (this.shouldUseOptionInput && !filterValue) {
+				this.reset()
+				return
+			}
+
 			// Prevents adding duplicate "Contains" or "DoesNotContain" filters with the same value on the same column
 			if ([FilterIds.Contains, FilterIds.DoesNotContain].includes(this.selectedOperator.id)) {
 				const columnFilters = this.getFilterForColumn(this.column)
 				if (columnFilters && columnFilters
 					.filter(fil => fil.operator.id === this.selectedOperator.id)
 					.map(fil => fil.value)
-					.includes(this.searchValue)) {
+					.includes(filterValue)) {
 					this.reset()
 					return
 				}
@@ -392,7 +474,11 @@ export default {
 			const filterObject = {
 				columnId: this.column.id,
 				operator: this.selectedOperator,
-				value: FilterIds.ContainsItem === this.selectedOperator.id ? this.searchOptions : this.searchValue,
+				value: this.getFilterValue(),
+			}
+			const displayValue = this.getFilterDisplayValue()
+			if (displayValue !== null) {
+				filterObject.displayValue = displayValue
 			}
 			if (!this.localViewSetting.filter) {
 				this.localViewSetting.filter = []
@@ -400,29 +486,50 @@ export default {
 			this.localViewSetting.filter.push(filterObject)
 			this.localViewSetting = JSON.parse(JSON.stringify(this.localViewSetting))
 		},
+		getFilterValue() {
+			if (FilterIds.ContainsItem === this.selectedOperator.id) {
+				return this.searchOptions
+			}
+			if (this.shouldUseOptionInput) {
+				return this.searchOption?.id ?? ''
+			}
+			return this.searchValue
+		},
+		// show the lable of the selection instead of magic value like @selection-id-1
+		getFilterDisplayValue() {
+			if (FilterIds.ContainsItem === this.selectedOperator.id) {
+				return null
+			}
+			if (this.shouldUseOptionInput) {
+				return this.searchOption?.label ?? ''
+			}
+			return null
+		},
 		reset() {
 			this.operator = null
 			this.searchValue = ''
+			this.searchOption = null
 			this.searchOptions = []
 			this.sortMode = this.getSortMode
 			this.selectOperator = false
 			this.selectValue = false
 		},
 		sort(mode) {
-			if (mode === this.getSortMode) {
-				this.sortMode = null
-				this.localViewSetting.sorting = null
-			} else {
-				if (mode !== 'ASC' && mode !== 'DESC') {
-					return
-				}
-				this.sortMode = mode
-				this.localViewSetting.sorting = [{
+			if (mode !== 'ASC' && mode !== 'DESC') {
+				return
+			}
+
+			const sorting = mode === this.getSortMode
+				? []
+				: [{
 					columnId: this.column.id,
 					mode,
 				}]
+
+			this.localViewSetting = {
+				...this.localViewSetting,
+				sorting,
 			}
-			this.localViewSetting = JSON.parse(JSON.stringify(this.localViewSetting))
 			this.close()
 		},
 		hideColumn() {
diff --git a/src/store/data.js b/src/store/data.js
index 3a0c5f5417..519ac3074b 100644
--- a/src/store/data.js
+++ b/src/store/data.js
@@ -233,16 +233,24 @@ export const useDataStore = defineStore('data', {
 		},
 
 		// ROWS
-		async loadRowsFromBE({ tableId, viewId, customFilters = null }) {
+		async loadRowsFromBE({ tableId, viewId, customFilters = null, sort = null }) {
 			const stateId = genStateKey(!!(viewId), viewId ?? tableId)
 			this.loading[stateId] = true
 			let res = null
 
 			try {
+				const params = {}
+				if (customFilters) {
+					params.customFilters = customFilters
+				}
+				if (sort) {
+					params.sort = sort
+				}
+
 				if (viewId) {
-					res = await axios.get(generateUrl('/apps/tables/row/view/' + viewId), { params: { customFilters } })
+					res = await axios.get(generateUrl('/apps/tables/row/view/' + viewId), { params })
 				} else {
-					res = await axios.get(generateUrl('/apps/tables/row/table/' + tableId), { params: { customFilters } })
+					res = await axios.get(generateUrl('/apps/tables/row/table/' + tableId), { params })
 				}
 			} catch (e) {
 				displayError(e, t('tables', 'Could not load rows.'))