diff --git a/src/app/dashboard/[teamSlug]/templates/(tabs)/list/page.tsx b/src/app/dashboard/[teamSlug]/templates/(tabs)/list/page.tsx
index 76f6b25ad..ae2a9e652 100644
--- a/src/app/dashboard/[teamSlug]/templates/(tabs)/list/page.tsx
+++ b/src/app/dashboard/[teamSlug]/templates/(tabs)/list/page.tsx
@@ -1,11 +1,30 @@
 import { Suspense } from 'react'
 import LoadingLayout from '@/features/dashboard/loading-layout'
+import {
+  TEMPLATES_DEFAULT_SORT,
+  TEMPLATES_PAGE_SIZE,
+} from '@/features/dashboard/templates/list/constants'
 import TemplatesTable from '@/features/dashboard/templates/list/table'
+import { HydrateClient, prefetch, trpc } from '@/trpc/server'
+
+export default async function TemplatesListPage({
+  params,
+}: PageProps<'/dashboard/[teamSlug]/templates/list'>) {
+  const { teamSlug } = await params
+
+  prefetch(
+    trpc.templates.getTemplates.infiniteQueryOptions({
+      teamSlug,
+      limit: TEMPLATES_PAGE_SIZE,
+      sort: TEMPLATES_DEFAULT_SORT,
+    })
+  )
 
-export default function TemplatesListPage() {
   return (
-    <Suspense fallback={<LoadingLayout />}>
-      <TemplatesTable />
-    </Suspense>
+    <HydrateClient>
+      <Suspense fallback={<LoadingLayout />}>
+        <TemplatesTable />
+      </Suspense>
+    </HydrateClient>
   )
 }
diff --git a/src/core/modules/templates/models.ts b/src/core/modules/templates/models.ts
index aa08bebab..4cccb32fc 100644
--- a/src/core/modules/templates/models.ts
+++ b/src/core/modules/templates/models.ts
@@ -1,3 +1,7 @@
+import type {
+  components as DashboardComponents,
+  paths as DashboardPaths,
+} from '@/contracts/dashboard-api'
 import type { components as InfraComponents } from '@/contracts/infra-api'
 
 export type Template = Pick<
@@ -23,3 +27,14 @@ export type DefaultTemplate = Template & {
   isDefault: true
   defaultDescription?: string
 }
+
+export type TemplatesSort = DashboardComponents['parameters']['templates_sort']
+
+export type ListTeamTemplatesOptions = NonNullable<
+  DashboardPaths['/templates']['get']['parameters']['query']
+>
+
+export interface ListTeamTemplatesResult {
+  data: Array<Template | DefaultTemplate>
+  nextCursor: string | null
+}
diff --git a/src/core/modules/templates/repository.server.ts b/src/core/modules/templates/repository.server.ts
index 680d2fbcb..460e30239 100644
--- a/src/core/modules/templates/repository.server.ts
+++ b/src/core/modules/templates/repository.server.ts
@@ -7,7 +7,12 @@ import {
   MOCK_DEFAULT_TEMPLATES_DATA,
   MOCK_TEMPLATES_DATA,
 } from '@/configs/mock-data'
-import type { DefaultTemplate, Template } from '@/core/modules/templates/models'
+import type {
+  DefaultTemplate,
+  ListTeamTemplatesOptions,
+  ListTeamTemplatesResult,
+  Template,
+} from '@/core/modules/templates/models'
 import {
   type AuthUserEmailResolver,
   getAuthUserEmailsById,
@@ -30,6 +35,9 @@ type TemplatesRepositoryDeps = {
 
 export interface TeamTemplatesRepository {
   getTeamTemplates(): Promise<RepoResult<{ templates: Template[] }>>
+  listTeamTemplates(
+    options: ListTeamTemplatesOptions
+  ): Promise<RepoResult<ListTeamTemplatesResult>>
   deleteTemplate(templateId: string): Promise<RepoResult<{ success: true }>>
   updateTemplateVisibility(
     templateId: string,
@@ -87,6 +95,62 @@ export function createTemplatesRepository(
         ),
       })
     },
+    async listTeamTemplates(options) {
+      if (USE_MOCK_DATA) {
+        return ok({ data: MOCK_TEMPLATES_DATA, nextCursor: null })
+      }
+
+      const res = await deps.apiClient.GET('/templates', {
+        params: {
+          query: options,
+        },
+        headers: {
+          ...deps.authHeaders(scope.accessToken, scope.teamId),
+        },
+      })
+
+      if (!res.response.ok || res.error) {
+        return err(
+          repoErrorFromHttp(
+            res.response.status,
+            res.error?.message ?? 'Failed to fetch templates',
+            res.error
+          )
+        )
+      }
+
+      if (!res.data?.data?.length) {
+        return ok({ data: [], nextCursor: res.data?.nextCursor ?? null })
+      }
+
+      const data = res.data.data.map((t): Template | DefaultTemplate => ({
+        templateID: t.templateID,
+        buildID: t.buildID,
+        cpuCount: t.cpuCount,
+        memoryMB: t.memoryMB,
+        diskSizeMB: t.diskSizeMB ?? 0,
+        public: t.public,
+        aliases: t.aliases,
+        names: t.names,
+        createdAt: t.createdAt,
+        updatedAt: t.updatedAt,
+        // Email resolution is deferred while the Supabase auth migration is
+        // in progress; the endpoint returns only the creator id for now.
+        createdBy: t.createdBy
+          ? { id: t.createdBy.id, email: t.createdBy.email ?? '' }
+          : null,
+        lastSpawnedAt: t.lastSpawnedAt ?? null,
+        spawnCount: t.spawnCount,
+        buildCount: t.buildCount,
+        envdVersion: t.envdVersion ?? '',
+        ...(t.isDefault && {
+          isDefault: true as const,
+          defaultDescription: t.defaultDescription ?? undefined,
+        }),
+      }))
+
+      return ok({ data, nextCursor: res.data.nextCursor ?? null })
+    },
     async deleteTemplate(templateId) {
       const res = await deps.infraClient.DELETE('/templates/{templateID}', {
         params: {
diff --git a/src/core/server/api/routers/templates.ts b/src/core/server/api/routers/templates.ts
index d063c251c..1883ed49e 100644
--- a/src/core/server/api/routers/templates.ts
+++ b/src/core/server/api/routers/templates.ts
@@ -36,11 +36,44 @@ const teamTemplatesRepositoryProcedure = protectedTeamProcedure.use(
 export const templatesRouter = createTRPCRouter({
   // QUERIES
 
-  getTemplates: teamTemplatesRepositoryProcedure.query(async ({ ctx }) => {
-    const result = await ctx.templatesRepository.getTeamTemplates()
-    if (!result.ok) throwTRPCErrorFromRepoError(result.error)
-    return result.data
-  }),
+  getTemplates: teamTemplatesRepositoryProcedure
+    .input(
+      z.object({
+        cursor: z.string().optional(),
+        limit: z.number().int().min(1).max(100).default(50),
+        cpuCount: z.number().int().positive().optional(),
+        memoryMB: z.number().int().positive().optional(),
+        public: z.boolean().optional(),
+        search: z.string().optional(),
+        sort: z
+          .enum([
+            'name_asc',
+            'name_desc',
+            'cpu_count_asc',
+            'cpu_count_desc',
+            'memory_mb_asc',
+            'memory_mb_desc',
+            'created_at_asc',
+            'created_at_desc',
+            'updated_at_asc',
+            'updated_at_desc',
+          ])
+          .default('updated_at_desc'),
+      })
+    )
+    .query(async ({ ctx, input }) => {
+      const result = await ctx.templatesRepository.listTeamTemplates({
+        cursor: input.cursor,
+        limit: input.limit,
+        cpuCount: input.cpuCount,
+        memoryMB: input.memoryMB,
+        public: input.public,
+        search: input.search,
+        sort: input.sort,
+      })
+      if (!result.ok) throwTRPCErrorFromRepoError(result.error)
+      return result.data
+    }),
 
   getDefaultTemplatesCached: templatesRepositoryProcedure.query(
     async ({ ctx }) => {
diff --git a/src/features/dashboard/templates/builds/table-cells.tsx b/src/features/dashboard/templates/builds/table-cells.tsx
index 2222fe610..36ef8c3e9 100644
--- a/src/features/dashboard/templates/builds/table-cells.tsx
+++ b/src/features/dashboard/templates/builds/table-cells.tsx
@@ -18,7 +18,6 @@ import CopyButtonInline from '@/ui/copy-button-inline'
 import { Badge } from '@/ui/primitives/badge'
 import { Button } from '@/ui/primitives/button'
 import { CheckIcon, CloseIcon } from '@/ui/primitives/icons'
-import { Loader } from '@/ui/primitives/loader'
 
 export function BuildId({ id }: { id: string }) {
   return (
@@ -61,42 +60,6 @@ export function Template({
   )
 }
 
-export function LoadMoreButton({
-  isLoading,
-  onLoadMore,
-}: {
-  isLoading: boolean
-  onLoadMore: () => void
-}) {
-  if (isLoading) {
-    return (
-      <span className="inline-flex items-center gap-1">
-        Loading
-        <Loader variant="dots" />
-      </span>
-    )
-  }
-  return (
-    <button
-      onClick={onLoadMore}
-      className="underline text-fg-secondary hover:text-accent-main-highlight transition-colors"
-    >
-      Load more
-    </button>
-  )
-}
-
-export function BackToTopButton({ onBackToTop }: { onBackToTop: () => void }) {
-  return (
-    <button
-      onClick={onBackToTop}
-      className="underline text-fg-secondary hover:text-accent-main-highlight transition-colors"
-    >
-      Back to top
-    </button>
-  )
-}
-
 export function Duration({
   createdAt,
   finishedAt,
diff --git a/src/features/dashboard/templates/builds/table.tsx b/src/features/dashboard/templates/builds/table.tsx
index 493280d3e..1f345e5bd 100644
--- a/src/features/dashboard/templates/builds/table.tsx
+++ b/src/features/dashboard/templates/builds/table.tsx
@@ -16,6 +16,7 @@ import type {
 import { useRouteParams } from '@/lib/hooks/use-route-params'
 import { cn } from '@/lib/utils/ui'
 import { useTRPC } from '@/trpc/client'
+import { BackToTopButton, LoadMoreButton } from '@/ui/pagination-buttons'
 import { ArrowDownIcon } from '@/ui/primitives/icons'
 import { Loader } from '@/ui/primitives/loader'
 import {
@@ -28,10 +29,8 @@ import {
 } from '@/ui/primitives/table'
 import BuildsEmpty from './empty'
 import {
-  BackToTopButton,
   BuildId,
   Duration,
-  LoadMoreButton,
   Reason,
   StartedAt,
   Status,
diff --git a/src/features/dashboard/templates/list/constants.ts b/src/features/dashboard/templates/list/constants.ts
new file mode 100644
index 000000000..1f44ffae4
--- /dev/null
+++ b/src/features/dashboard/templates/list/constants.ts
@@ -0,0 +1,16 @@
+import type { SortingState } from '@tanstack/react-table'
+import type { TemplatesSort } from '@/core/modules/templates/models'
+
+export const TEMPLATES_PAGE_SIZE = 50
+
+export const TEMPLATES_DEFAULT_SORT_COLUMN_ID = 'createdAt'
+export const TEMPLATES_DEFAULT_SORT_BASE = 'created_at'
+export const TEMPLATES_DEFAULT_SORT_DESC = true
+
+export const TEMPLATES_DEFAULT_SORT: TemplatesSort = `${TEMPLATES_DEFAULT_SORT_BASE}_${
+  TEMPLATES_DEFAULT_SORT_DESC ? 'desc' : 'asc'
+}`
+
+export const TEMPLATES_DEFAULT_SORTING: SortingState = [
+  { id: TEMPLATES_DEFAULT_SORT_COLUMN_ID, desc: TEMPLATES_DEFAULT_SORT_DESC },
+]
diff --git a/src/features/dashboard/templates/list/header.tsx b/src/features/dashboard/templates/list/header.tsx
index 1b0f9120c..0eb2ce93d 100644
--- a/src/features/dashboard/templates/list/header.tsx
+++ b/src/features/dashboard/templates/list/header.tsx
@@ -1,6 +1,7 @@
 import type { Table } from '@tanstack/react-table'
 import { Suspense } from 'react'
 import type { Template } from '@/core/modules/templates/models'
+import { useTemplateTableStore } from './stores/table-store'
 import TemplatesTableFilters from './table-filters'
 import { SearchInput } from './table-search'
 
@@ -11,13 +12,16 @@ interface TemplatesHeaderProps {
 export default function TemplatesHeader({ table }: TemplatesHeaderProps) {
   'use no memo'
 
-  const { columnFilters, globalFilter } = table.getState()
-  const showFilteredRowCount = columnFilters.length > 0 || Boolean(globalFilter)
+  const { globalFilter, cpuCount, memoryMB, isPublic } = useTemplateTableStore()
+  const isFiltered =
+    Boolean(globalFilter) ||
+    cpuCount !== undefined ||
+    memoryMB !== undefined ||
+    isPublic !== undefined
 
-  const totalCount = table.options.data.length
-  const filteredCount = showFilteredRowCount
-    ? table.getFilteredRowModel().rows.length
-    : totalCount
+  // With server-side pagination we only know how many rows are currently
+  // loaded, not the grand total.
+  const loadedCount = table.options.data.length
 
   return (
     <div className="flex min-w-0 flex-wrap items-start gap-1 sm:items-center">
@@ -33,17 +37,12 @@ export default function TemplatesHeader({ table }: TemplatesHeaderProps) {
       <div className="hidden w-2 shrink-0 sm:block" aria-hidden="true" />
 
       <span className="prose-label-highlight h-9 flex w-full min-w-0 items-center gap-1 uppercase sm:w-auto">
-        {showFilteredRowCount ? (
-          <>
-            <span className="text-fg">
-              {filteredCount} {filteredCount === 1 ? 'result' : 'results'}
-            </span>
-            <span className="text-fg-tertiary"> · </span>
-            <span className="text-fg-tertiary">{totalCount} total</span>
-          </>
-        ) : (
-          <span className="text-fg-tertiary">{totalCount} total</span>
-        )}
+        <span className="text-fg">
+          {loadedCount} {loadedCount === 1 ? 'template' : 'templates'}
+        </span>
+        {isFiltered ? (
+          <span className="text-fg-tertiary"> · filtered</span>
+        ) : null}
       </span>
     </div>
   )
diff --git a/src/features/dashboard/templates/list/stores/table-store.ts b/src/features/dashboard/templates/list/stores/table-store.ts
index 5efbd4705..db239b7b7 100644
--- a/src/features/dashboard/templates/list/stores/table-store.ts
+++ b/src/features/dashboard/templates/list/stores/table-store.ts
@@ -2,6 +2,7 @@ import type { OnChangeFn, SortingState } from '@tanstack/react-table'
 import { create } from 'zustand'
 import { createJSONStorage, persist } from 'zustand/middleware'
 import { createHashStorage } from '@/lib/utils/store'
+import { TEMPLATES_DEFAULT_SORTING } from '../constants'
 import { trackTemplateTableInteraction } from '../table-config'
 
 interface TemplateTableState {
@@ -33,7 +34,7 @@ type Store = TemplateTableState & TemplateTableActions
 
 const initialState: TemplateTableState = {
   // Table state
-  sorting: [{ id: 'updatedAt', desc: true }],
+  sorting: TEMPLATES_DEFAULT_SORTING,
   globalFilter: '',
   // Filter state
   cpuCount: undefined,
diff --git a/src/features/dashboard/templates/list/table-body.tsx b/src/features/dashboard/templates/list/table-body.tsx
index 4d9f74b80..5722c0771 100644
--- a/src/features/dashboard/templates/list/table-body.tsx
+++ b/src/features/dashboard/templates/list/table-body.tsx
@@ -2,8 +2,10 @@ import { flexRender, type Table } from '@tanstack/react-table'
 import type { RefObject } from 'react'
 import type { Template } from '@/core/modules/templates/models'
 import { useVirtualRows } from '@/lib/hooks/use-virtual-rows'
+import { cn } from '@/lib/utils'
 import { DataTableBody, DataTableCell, DataTableRow } from '@/ui/data-table'
 import Empty from '@/ui/empty'
+import { LoadMoreButton } from '@/ui/pagination-buttons'
 import { Button } from '@/ui/primitives/button'
 import { CloseIcon, ExternalLinkIcon } from '@/ui/primitives/icons'
 import { useTemplateTableStore } from './stores/table-store'
@@ -16,16 +18,25 @@ interface TemplatesTableBodyProps {
   templates: Template[] | undefined
   table: Table<Template>
   scrollRef: RefObject<HTMLDivElement | null>
+  hasNextPage: boolean
+  isFetchingNextPage: boolean
+  fetchNextPage: () => void
+  isRefetching: boolean
 }
 
 export function TemplatesTableBody({
   templates,
   table,
   scrollRef,
+  hasNextPage,
+  isFetchingNextPage,
+  fetchNextPage,
+  isRefetching,
 }: TemplatesTableBodyProps) {
   'use no memo'
 
-  const resetFilters = useTemplateTableStore((state) => state.resetFilters)
+  const { resetFilters, globalFilter, cpuCount, memoryMB, isPublic } =
+    useTemplateTableStore()
 
   const centerRows = table.getCenterRows()
   const {
@@ -47,9 +58,10 @@ export function TemplatesTableBody({
   const isEmpty = templates && centerRows.length === 0
 
   const hasFilter =
-    Object.values(table.getState().columnFilters).some(
-      (filter) => filter.value !== undefined
-    ) || table.getState().globalFilter !== ''
+    Boolean(globalFilter) ||
+    cpuCount !== undefined ||
+    memoryMB !== undefined ||
+    isPublic !== undefined
 
   if (isEmpty) {
     if (hasFilter) {
@@ -85,21 +97,35 @@ export function TemplatesTableBody({
   }
 
   return (
-    <DataTableBody virtualizedTotalHeight={virtualizedTotalHeight}>
-      {virtualPaddingTop > 0 && <div style={{ height: virtualPaddingTop }} />}
-      {rows.map((row) => (
-        <DataTableRow
-          key={row.id}
-          isSelected={row.getIsSelected()}
-          className="h-8 border-b"
-        >
-          {row.getVisibleCells().map((cell) => (
-            <DataTableCell key={cell.id} cell={cell}>
-              {flexRender(cell.column.columnDef.cell, cell.getContext())}
-            </DataTableCell>
-          ))}
-        </DataTableRow>
-      ))}
-    </DataTableBody>
+    <>
+      <DataTableBody
+        virtualizedTotalHeight={virtualizedTotalHeight}
+        className={cn(isRefetching && 'opacity-70 transition-opacity')}
+      >
+        {virtualPaddingTop > 0 && <div style={{ height: virtualPaddingTop }} />}
+        {rows.map((row) => (
+          <DataTableRow
+            key={row.id}
+            isSelected={row.getIsSelected()}
+            className="h-8 border-b"
+          >
+            {row.getVisibleCells().map((cell) => (
+              <DataTableCell key={cell.id} cell={cell}>
+                {flexRender(cell.column.columnDef.cell, cell.getContext())}
+              </DataTableCell>
+            ))}
+          </DataTableRow>
+        ))}
+      </DataTableBody>
+
+      {hasNextPage && (
+        <div className="flex items-center justify-center py-3 text-fg-tertiary max-md:sticky max-md:left-0 max-md:w-[calc(100svw-1.5rem)]">
+          <LoadMoreButton
+            isLoading={isFetchingNextPage}
+            onLoadMore={fetchNextPage}
+          />
+        </div>
+      )}
+    </>
   )
 }
diff --git a/src/features/dashboard/templates/list/table-cells.tsx b/src/features/dashboard/templates/list/table-cells.tsx
index 591cec46a..f8b983a43 100644
--- a/src/features/dashboard/templates/list/table-cells.tsx
+++ b/src/features/dashboard/templates/list/table-cells.tsx
@@ -5,7 +5,6 @@ import type { CellContext } from '@tanstack/react-table'
 import { useMemo, useState } from 'react'
 import type { DefaultTemplate, Template } from '@/core/modules/templates/models'
 import { useClipboard } from '@/lib/hooks/use-clipboard'
-import { useRouteParams } from '@/lib/hooks/use-route-params'
 import {
   defaultErrorToast,
   defaultSuccessToast,
@@ -56,16 +55,18 @@ export function ActionsCell({
 }: CellContext<Template | DefaultTemplate, unknown>) {
   const template = row.original
   const { team } = useDashboard()
-  const { teamSlug } = useRouteParams<'/dashboard/[teamSlug]/templates'>()
 
   const { toast } = useToast()
   const trpc = useTRPC()
   const queryClient = useQueryClient()
+  // Path-level key matches the paginated infinite query across every
+  // sort/filter/search variant currently in the cache.
+  const templatesListKey = trpc.templates.getTemplates.pathKey()
   const [isDeleteDialogOpen, setIsDeleteDialogOpen] = useState(false)
 
   const updateTemplateMutation = useMutation(
     trpc.templates.updateTemplate.mutationOptions({
-      onSuccess: async (data, variables) => {
+      onSuccess: (data) => {
         const templateName = template.aliases[0] || template.templateID
 
         toast(
@@ -77,30 +78,6 @@ export function ActionsCell({
             </>
           )
         )
-
-        await queryClient.cancelQueries({
-          queryKey: trpc.templates.getTemplates.queryKey({
-            teamSlug,
-          }),
-        })
-
-        queryClient.setQueryData(
-          trpc.templates.getTemplates.queryKey({
-            teamSlug,
-          }),
-          (old) => {
-            if (!old?.templates) return old
-
-            return {
-              ...old,
-              templates: old.templates.map((t: Template) =>
-                t.templateID === variables.templateId
-                  ? { ...t, public: variables.public }
-                  : t
-              ),
-            }
-          }
-        )
       },
       onError: (error) => {
         const templateName = template.aliases[0] || template.templateID
@@ -111,18 +88,14 @@ export function ActionsCell({
         )
       },
       onSettled: () => {
-        queryClient.invalidateQueries({
-          queryKey: trpc.templates.getTemplates.queryKey({
-            teamSlug,
-          }),
-        })
+        queryClient.invalidateQueries({ queryKey: templatesListKey })
       },
     })
   )
 
   const deleteTemplateMutation = useMutation(
     trpc.templates.deleteTemplate.mutationOptions({
-      onSuccess: async (_, variables) => {
+      onSuccess: () => {
         const templateName = template.aliases[0] || template.templateID
         toast(
           defaultSuccessToast(
@@ -133,32 +106,8 @@ export function ActionsCell({
             </>
           )
         )
-
-        // stop ongoing invlaidations and remove template from state while refetch is going in the background
-
-        await queryClient.cancelQueries({
-          queryKey: trpc.templates.getTemplates.queryKey({
-            teamSlug,
-          }),
-        })
-
-        queryClient.setQueryData(
-          trpc.templates.getTemplates.queryKey({
-            teamSlug,
-          }),
-
-          (old) => {
-            if (!old?.templates) return old
-            return {
-              ...old,
-              templates: old.templates.filter(
-                (t: Template) => t.templateID !== variables.templateId
-              ),
-            }
-          }
-        )
       },
-      onError: (error, _variables) => {
+      onError: (error) => {
         const templateName = template.aliases[0] || template.templateID
         toast(
           defaultErrorToast(
@@ -168,12 +117,7 @@ export function ActionsCell({
       },
       onSettled: () => {
         setIsDeleteDialogOpen(false)
-
-        queryClient.invalidateQueries({
-          queryKey: trpc.templates.getTemplates.queryKey({
-            teamSlug,
-          }),
-        })
+        queryClient.invalidateQueries({ queryKey: templatesListKey })
       },
     })
   )
diff --git a/src/features/dashboard/templates/list/table-config.tsx b/src/features/dashboard/templates/list/table-config.tsx
index a2f051eab..750c158bd 100644
--- a/src/features/dashboard/templates/list/table-config.tsx
+++ b/src/features/dashboard/templates/list/table-config.tsx
@@ -1,12 +1,8 @@
 'use client'
 
-import { rankItem } from '@tanstack/match-sorter-utils'
 import {
   type ColumnDef,
-  type FilterFn,
   getCoreRowModel,
-  getFilteredRowModel,
-  getSortedRowModel,
   type TableOptions,
 } from '@tanstack/react-table'
 import posthog from 'posthog-js'
@@ -24,33 +20,6 @@ import {
   VisibilityCell,
 } from './table-cells'
 
-// FILTERS
-export const fuzzyFilter: FilterFn<unknown> = (
-  row,
-  columnId,
-  value,
-  addMeta
-) => {
-  // Skip undefined values
-  if (!value || !value.length) return true
-
-  const searchValue = value.toLowerCase()
-  const rowValue = row.getValue(columnId)
-
-  // Handle null/undefined row values
-  if (rowValue == null) return false
-
-  // Convert row value to string and lowercase for comparison
-  const itemStr = String(rowValue).toLowerCase()
-  const itemRank = rankItem(itemStr, searchValue)
-
-  addMeta({
-    itemRank,
-  })
-
-  return itemRank.passed
-}
-
 // TABLE CONFIG
 export const fallbackData: (Template | DefaultTemplate)[] = []
 
@@ -82,6 +51,7 @@ export const useColumns = (deps: unknown[]) => {
         header: 'ID',
         size: 156,
         enableResizing: false,
+        enableSorting: false,
         cell: TemplateIdCell,
       },
       {
@@ -161,18 +131,14 @@ export const useColumns = (deps: unknown[]) => {
 export const templatesTableConfig: Partial<
   TableOptions<Template | DefaultTemplate>
 > = {
-  filterFns: {
-    fuzzy: fuzzyFilter,
-  },
   getCoreRowModel: getCoreRowModel(),
-  getFilteredRowModel: getFilteredRowModel(),
-  getSortedRowModel: getSortedRowModel(),
+  // Sorting, filtering, and search are performed server-side; the table is a
+  // pure renderer over the rows returned by the paginated query.
+  manualSorting: true,
+  manualFiltering: true,
   enableSorting: true,
   enableMultiSort: false,
   enableSortingRemoval: false,
   columnResizeMode: 'onChange',
   enableColumnResizing: true,
-  enableGlobalFilter: true,
-  // @ts-expect-error globalFilterFn is not a valid option
-  globalFilterFn: 'fuzzy',
 }
diff --git a/src/features/dashboard/templates/list/table.tsx b/src/features/dashboard/templates/list/table.tsx
index 922c195ef..16b18b2bd 100644
--- a/src/features/dashboard/templates/list/table.tsx
+++ b/src/features/dashboard/templates/list/table.tsx
@@ -1,16 +1,22 @@
 'use client'
 
-import { useSuspenseQuery } from '@tanstack/react-query'
 import {
-  type ColumnFiltersState,
+  keepPreviousData,
+  useSuspenseInfiniteQuery,
+} from '@tanstack/react-query'
+import {
   type ColumnSizingState,
   flexRender,
   type TableOptions,
   useReactTable,
 } from '@tanstack/react-table'
-import { useEffect, useMemo, useRef, useState } from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { useLocalStorage } from 'usehooks-ts'
-import type { Template } from '@/core/modules/templates/models'
+import type {
+  DefaultTemplate,
+  Template,
+  TemplatesSort,
+} from '@/core/modules/templates/models'
 import { useColumnSizeVars } from '@/lib/hooks/use-column-size-vars'
 import { useRouteParams } from '@/lib/hooks/use-route-params'
 import { cn } from '@/lib/utils'
@@ -25,52 +31,92 @@ import {
 import ErrorBoundary from '@/ui/error'
 import HelpTooltip from '@/ui/help-tooltip'
 import { SIDEBAR_TRANSITION_CLASSNAMES } from '@/ui/primitives/sidebar'
+import {
+  TEMPLATES_DEFAULT_SORT_BASE,
+  TEMPLATES_DEFAULT_SORT_DESC,
+  TEMPLATES_PAGE_SIZE,
+} from './constants'
 import TemplatesHeader from './header'
 import { useTemplateTableStore } from './stores/table-store'
 import { TemplatesTableBody as TableBody } from './table-body'
 import { fallbackData, templatesTableConfig, useColumns } from './table-config'
 
+const COLUMN_TO_SORT_BASE: Record<string, string> = {
+  name: 'name',
+  cpuCount: 'cpu_count',
+  memoryMB: 'memory_mb',
+  createdAt: 'created_at',
+  updatedAt: 'updated_at',
+}
+
 export default function TemplatesTable() {
   'use no memo'
 
   const trpc = useTRPC()
   const { teamSlug } = useRouteParams<'/dashboard/[teamSlug]/templates'>()
 
-  const { data: templatesData, error: templatesError } = useSuspenseQuery(
-    trpc.templates.getTemplates.queryOptions(
-      { teamSlug },
+  const { sorting, setSorting, globalFilter, setGlobalFilter } =
+    useTemplateTableStore()
+  const { cpuCount, memoryMB, isPublic } = useTemplateTableStore()
+
+  // Derive the single server sort token from the active sort column + direction.
+  const sortColumn = sorting[0]
+  const sortBase =
+    (sortColumn && COLUMN_TO_SORT_BASE[sortColumn.id]) ??
+    TEMPLATES_DEFAULT_SORT_BASE
+  const isDesc = sortColumn
+    ? sortColumn.desc !== false
+    : TEMPLATES_DEFAULT_SORT_DESC
+  const sort = `${sortBase}_${isDesc ? 'desc' : 'asc'}` as TemplatesSort
+
+  const {
+    data,
+    error: templatesError,
+    fetchNextPage,
+    hasNextPage,
+    isFetchingNextPage,
+    isFetching,
+  } = useSuspenseInfiniteQuery(
+    trpc.templates.getTemplates.infiniteQueryOptions(
+      {
+        teamSlug,
+        limit: TEMPLATES_PAGE_SIZE,
+        cpuCount,
+        memoryMB,
+        public: isPublic,
+        search: globalFilter || undefined,
+        sort,
+      },
       {
-        refetchOnMount: false,
-        refetchOnWindowFocus: false,
-        refetchOnReconnect: false,
+        getNextPageParam: (lastPage) => lastPage.nextCursor ?? undefined,
+        initialCursor: undefined,
+        placeholderData: keepPreviousData,
       }
     )
   )
 
-  const { data: defaultTemplatesData } = useSuspenseQuery(
-    trpc.templates.getDefaultTemplatesCached.queryOptions(undefined, {
-      refetchOnMount: false,
-      refetchOnWindowFocus: false,
-      refetchOnReconnect: false,
-    })
+  const templates = useMemo<Array<Template | DefaultTemplate>>(
+    () => data?.pages.flatMap((page) => page.data) ?? [],
+    [data]
   )
 
-  const templates = useMemo(
-    () => [
-      ...(defaultTemplatesData?.templates ?? []),
-      ...(templatesData?.templates ?? []),
-    ],
-    [templatesData, defaultTemplatesData]
+  const { isRefetching, clearRefetching } = useTemplatesRefetchTracking(
+    sort,
+    globalFilter,
+    cpuCount,
+    memoryMB,
+    isPublic
   )
 
-  const scrollRef = useRef<HTMLDivElement>(null)
-
-  const { sorting, setSorting, globalFilter, setGlobalFilter } =
-    useTemplateTableStore()
+  useEffect(() => {
+    if (!isFetching && isRefetching) {
+      clearRefetching()
+    }
+  }, [isFetching, isRefetching, clearRefetching])
 
-  const { cpuCount, memoryMB, isPublic } = useTemplateTableStore()
+  const isListDimmed = isRefetching && templates.length > 0
 
-  const [columnFilters, setColumnFilters] = useState<ColumnFiltersState>([])
+  const scrollRef = useRef<HTMLDivElement>(null)
 
   const [columnSizing, setColumnSizing] = useLocalStorage<ColumnSizingState>(
     'templates:columnSizing:v3',
@@ -81,37 +127,6 @@ export default function TemplatesTable() {
     }
   )
 
-  // Effect hooks for filters
-  useEffect(() => {
-    let newFilters = [...columnFilters]
-
-    // Handle CPU filter
-    if (!cpuCount) {
-      newFilters = newFilters.filter((f) => f.id !== 'cpuCount')
-    } else {
-      newFilters = newFilters.filter((f) => f.id !== 'cpuCount')
-      newFilters.push({ id: 'cpuCount', value: cpuCount })
-    }
-
-    // Handle memory filter
-    if (!memoryMB) {
-      newFilters = newFilters.filter((f) => f.id !== 'memoryMB')
-    } else {
-      newFilters = newFilters.filter((f) => f.id !== 'memoryMB')
-      newFilters.push({ id: 'memoryMB', value: memoryMB })
-    }
-
-    // Handle public filter
-    if (isPublic === undefined) {
-      newFilters = newFilters.filter((f) => f.id !== 'public')
-    } else {
-      newFilters = newFilters.filter((f) => f.id !== 'public')
-      newFilters.push({ id: 'public', value: isPublic })
-    }
-
-    setColumnFilters(newFilters)
-  }, [cpuCount, memoryMB, isPublic])
-
   const columns = useColumns([])
 
   const table = useReactTable<Template>({
@@ -122,27 +137,21 @@ export default function TemplatesTable() {
       globalFilter,
       sorting,
       columnSizing,
-      columnFilters,
     },
     onGlobalFilterChange: setGlobalFilter,
     onSortingChange: setSorting,
     onColumnSizingChange: setColumnSizing,
-    onColumnFiltersChange: setColumnFilters,
   } as TableOptions<Template>)
 
   const columnSizeVars = useColumnSizeVars(table)
 
-  const resetScroll = () => {
+  // biome-ignore lint/correctness/useExhaustiveDependencies: scroll reset is triggered by query-input changes
+  useEffect(() => {
     if (scrollRef.current) {
       scrollRef.current.scrollTop = 0
       scrollRef.current.scrollLeft = 0
     }
-  }
-
-  // Add effect hook for scrolling to top when sorting or global filter changes
-  useEffect(() => {
-    resetScroll()
-  }, [sorting, globalFilter])
+  }, [sort, globalFilter, cpuCount, memoryMB, isPublic])
 
   if (templatesError) {
     return (
@@ -212,9 +221,37 @@ export default function TemplatesTable() {
             templates={templates}
             table={table}
             scrollRef={scrollRef}
+            hasNextPage={hasNextPage}
+            isFetchingNextPage={isFetchingNextPage}
+            fetchNextPage={fetchNextPage}
+            isRefetching={isListDimmed}
           />
         </DataTable>
       </div>
     </ClientOnly>
   )
 }
+
+function useTemplatesRefetchTracking(
+  sort: string,
+  globalFilter: string,
+  cpuCount: number | undefined,
+  memoryMB: number | undefined,
+  isPublic: boolean | undefined
+) {
+  const [isRefetching, setIsRefetching] = useState(false)
+  const isFirstRender = useRef(true)
+
+  // biome-ignore lint/correctness/useExhaustiveDependencies: these are change triggers, not values read in the effect
+  useEffect(() => {
+    if (isFirstRender.current) {
+      isFirstRender.current = false
+      return
+    }
+    setIsRefetching(true)
+  }, [sort, globalFilter, cpuCount, memoryMB, isPublic])
+
+  const clearRefetching = useCallback(() => setIsRefetching(false), [])
+
+  return { isRefetching, clearRefetching }
+}
diff --git a/src/ui/pagination-buttons.tsx b/src/ui/pagination-buttons.tsx
new file mode 100644
index 000000000..4a696fd6b
--- /dev/null
+++ b/src/ui/pagination-buttons.tsx
@@ -0,0 +1,41 @@
+'use client'
+
+import { Loader } from '@/ui/primitives/loader'
+
+export function LoadMoreButton({
+  isLoading,
+  onLoadMore,
+}: {
+  isLoading: boolean
+  onLoadMore: () => void
+}) {
+  if (isLoading) {
+    return (
+      <span className="inline-flex items-center gap-1">
+        Loading
+        <Loader variant="dots" />
+      </span>
+    )
+  }
+  return (
+    <button
+      type="button"
+      onClick={onLoadMore}
+      className="underline text-fg-secondary hover:text-accent-main-highlight transition-colors"
+    >
+      Load more
+    </button>
+  )
+}
+
+export function BackToTopButton({ onBackToTop }: { onBackToTop: () => void }) {
+  return (
+    <button
+      type="button"
+      onClick={onBackToTop}
+      className="underline text-fg-secondary hover:text-accent-main-highlight transition-colors"
+    >
+      Back to top
+    </button>
+  )
+}